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());
    }

}
