import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Die Test-Klasse KlausurTester.
 *
 * @author  (Ihr Name)
 * @version (eine Versionsnummer oder ein Datum)
 */
public class KlausurTester
{
    /**
     * Konstruktor fuer die Test-Klasse KlausurTester
     */
    public KlausurTester()
    {
    }

    /**
     *  Setzt das Testgerüst fuer den Test.
     *
     * Wird vor jeder Testfall-Methode aufgerufen.
     */
    @Before
    public void setUp()
    {
    }

    /**
     * Gibt das Testgerüst wieder frei.
     *
     * Wird nach jeder Testfall-Methode aufgerufen.
     */
    @After
    public void tearDown()
    {
    }

    @Test
    public void test00()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(12,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(k.getAnzahl(),1);
        k.reset();
        assertEquals(k.getAnzahl(),0);
        k.noteEintragen(3);
        assertEquals(k.getBesteNote(),3);
        assertEquals(k.getSchlechtesteNote(),3);
        assertEquals(k.getDurchschnitt(),3.0,0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test01()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(7,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.6666666666666665,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(7,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test02()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.833333333333333,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.428571428571429,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.444444444444445,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.1,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.363636363636363,k.getDurchschnitt(),0.001);
        assertEquals(11,k.getAnzahl());
    }

    @Test
    public void test03()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(6,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(7.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
    }

    @Test
    public void test04()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.166666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.857142857142857,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.888888888888889,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.3,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test05()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test06()
    {
        Klausur k = new Klausur();
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(12,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test07()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(13,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(13,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.833333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.714285714285714,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test08()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test09()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(10.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(13,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(11.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(13.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test10()
    {
        Klausur k = new Klausur();
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.6666666666666665,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test11()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(3,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(1.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test12()
    {
        Klausur k = new Klausur();
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test13()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test14()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(8,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(8,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(4.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.166666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(11,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(5.571428571428571,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(11,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(5.375,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.777777777777778,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
    }

    @Test
    public void test15()
    {
        Klausur k = new Klausur();
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test16()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test17()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.714285714285714,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test18()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.6666666666666665,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.833333333333333,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test19()
    {
        Klausur k = new Klausur();
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(6,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(4.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(8,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(4.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.166666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test20()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test21()
    {
        Klausur k = new Klausur();
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.142857142857142,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test22()
    {
        Klausur k = new Klausur();
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(8,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(8,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(10,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.714285714285714,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.625,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.222222222222221,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.8,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
    }

    @Test
    public void test23()
    {
        Klausur k = new Klausur();
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test24()
    {
        Klausur k = new Klausur();
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test25()
    {
        Klausur k = new Klausur();
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(12,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.428571428571429,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test26()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(7,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(7,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(2.6666666666666665,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(1,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test27()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(10,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test28()
    {
        Klausur k = new Klausur();
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test29()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(6,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test30()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test31()
    {
        Klausur k = new Klausur();
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test32()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(10,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(11,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.833333333333333,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.142857142857143,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.625,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
    }

    @Test
    public void test33()
    {
        Klausur k = new Klausur();
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());

        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test34()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test35()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(9.142857142857142,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.75,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
    }

    @Test
    public void test36()
    {
        Klausur k = new Klausur();
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(14,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test37()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test38()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(15,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(12.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(15,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(9.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(10.142857142857142,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.875,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.777777777777779,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.4,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.7272727272727275,k.getDurchschnitt(),0.001);
        assertEquals(11,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(12,k.getAnzahl());
    }

    @Test
    public void test39()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test40()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.833333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.571428571428571,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
    }

    @Test
    public void test41()
    {
        Klausur k = new Klausur();
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(13,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test42()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test43()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(4,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
    }

    @Test
    public void test44()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(11,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test45()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(14,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.833333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test46()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.571428571428571,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.375,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.111111111111111,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.9,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
    }

    @Test
    public void test47()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.571428571428571,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
    }

    @Test
    public void test48()
    {
        Klausur k = new Klausur();
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(12,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test49()
    {
        Klausur k = new Klausur();
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test50()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test51()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(13,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test52()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(10,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test53()
    {
        Klausur k = new Klausur();
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test54()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test55()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(10,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test56()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(9,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.833333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test57()
    {
        Klausur k = new Klausur();
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(11.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(7,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test58()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(13,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test59()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test60()
    {
        Klausur k = new Klausur();
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(13,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
    }

    @Test
    public void test61()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test62()
    {
        Klausur k = new Klausur();
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test63()
    {
        Klausur k = new Klausur();
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(15,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test64()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test65()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(13.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(13.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(11.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(15,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test66()
    {
        Klausur k = new Klausur();
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(15,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(10.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(7.142857142857143,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.555555555555555,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.7,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.545454545454546,k.getDurchschnitt(),0.001);
        assertEquals(11,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(5,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test67()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(7,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(7,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test68()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test69()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(11,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(11,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(11,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.4,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(13,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.833333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test70()
    {
        Klausur k = new Klausur();
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(10,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(8,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test71()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(15,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(11,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(11,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(7.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(9.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test72()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(9,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.6666666666666665,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(9,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(14.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(15,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test73()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(10,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.166666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.142857142857143,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(10,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(9,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.2,k.getDurchschnitt(),0.001);
        assertEquals(10,k.getAnzahl());
    }

    @Test
    public void test74()
    {
        Klausur k = new Klausur();
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(7.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
    }

    @Test
    public void test75()
    {
        Klausur k = new Klausur();
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(13,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(9.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(13,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test76()
    {
        Klausur k = new Klausur();
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(9,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(7.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.166666666666666,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test77()
    {
        Klausur k = new Klausur();
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test78()
    {
        Klausur k = new Klausur();
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(6.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(8,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(6.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(2.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(5,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(1.6666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test79()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(14,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(11,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(11,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(11,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test80()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(12,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(13,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.285714285714286,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(13,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(8,k.getAnzahl());
    }

    @Test
    public void test81()
    {
        Klausur k = new Klausur();
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(15,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(15,k.getSchlechtesteNote());
        assertEquals(15.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test82()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(13,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test83()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(14,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(14,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.8,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(7.166666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(14,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.142857142857143,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test84()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(12.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(3,k.getSchlechtesteNote());
        assertEquals(3.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test85()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(13,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(11.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(13,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(10.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test86()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test87()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(14,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test88()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(4.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test89()
    {
        Klausur k = new Klausur();
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(9,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(4,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test90()
    {
        Klausur k = new Klausur();
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(13,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
    }

    @Test
    public void test91()
    {
        Klausur k = new Klausur();
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(14,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

    @Test
    public void test92()
    {
        Klausur k = new Klausur();
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.333333333333333,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(6.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test93()
    {
        Klausur k = new Klausur();
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(11);
        assertEquals(11,k.getBesteNote());
        assertEquals(11,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(11,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
    }

    @Test
    public void test94()
    {
        Klausur k = new Klausur();
        k.noteEintragen(6);
        assertEquals(6,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(6.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(12,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(6.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
    }

    @Test
    public void test95()
    {
        Klausur k = new Klausur();
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(12,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(12,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(10.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(7,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(7.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(15);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(12.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(11.25,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(15,k.getBesteNote());
        assertEquals(7,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test96()
    {
        Klausur k = new Klausur();
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(3,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(1.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(3,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(1.6666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(9,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.2,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
    }

    @Test
    public void test97()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(12,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(4.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(3.8333333333333335,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(12,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.428571428571429,k.getDurchschnitt(),0.001);
        assertEquals(7,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(13,k.getBesteNote());
        assertEquals(13,k.getSchlechtesteNote());
        assertEquals(13.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(9);
        assertEquals(13,k.getBesteNote());
        assertEquals(9,k.getSchlechtesteNote());
        assertEquals(11.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
    }

    @Test
    public void test98()
    {
        Klausur k = new Klausur();
        k.noteEintragen(1);
        assertEquals(1,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(1.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(4);
        assertEquals(4,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.5,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(4,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.3333333333333335,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(3);
        assertEquals(4,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(2.5,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.6,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(8,k.getBesteNote());
        assertEquals(1,k.getSchlechtesteNote());
        assertEquals(3.3333333333333335,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(2);
        assertEquals(2,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(2.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(13);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(9.666666666666666,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(10.75,k.getDurchschnitt(),0.001);
        assertEquals(4,k.getAnzahl());
        k.noteEintragen(7);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(5,k.getAnzahl());
        k.noteEintragen(12);
        assertEquals(14,k.getBesteNote());
        assertEquals(2,k.getSchlechtesteNote());
        assertEquals(10.333333333333334,k.getDurchschnitt(),0.001);
        assertEquals(6,k.getAnzahl());
    }

    @Test
    public void test99()
    {
        Klausur k = new Klausur();
        k.noteEintragen(14);
        assertEquals(14,k.getBesteNote());
        assertEquals(14,k.getSchlechtesteNote());
        assertEquals(14.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(8,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(8,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(4.666666666666667,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(5);
        assertEquals(5,k.getBesteNote());
        assertEquals(5,k.getSchlechtesteNote());
        assertEquals(5.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(0);
        assertEquals(0,k.getBesteNote());
        assertEquals(0,k.getSchlechtesteNote());
        assertEquals(0.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.reset();
        assertEquals(0,k.getAnzahl());
        k.noteEintragen(10);
        assertEquals(10,k.getBesteNote());
        assertEquals(10,k.getSchlechtesteNote());
        assertEquals(10.0,k.getDurchschnitt(),0.001);
        assertEquals(1,k.getAnzahl());
        k.noteEintragen(8);
        assertEquals(10,k.getBesteNote());
        assertEquals(8,k.getSchlechtesteNote());
        assertEquals(9.0,k.getDurchschnitt(),0.001);
        assertEquals(2,k.getAnzahl());
        k.noteEintragen(6);
        assertEquals(10,k.getBesteNote());
        assertEquals(6,k.getSchlechtesteNote());
        assertEquals(8.0,k.getDurchschnitt(),0.001);
        assertEquals(3,k.getAnzahl());
    }

}