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

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

    /**
     *  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()
    {
    }

    private int ggt(int a, int b)
    {
        a = Math.abs(a);
        while(b != 0)
        {
            int t = b;
            b = a % b;
            a = t;
        }
        return a;
    }

    @Test
    public void test00()
    {
        Bruch b1 = new Bruch(-9,-6);
        Bruch b2 = new Bruch(-4,-9);
        assertEquals(true, b1.getNenner() > 0);
        assertEquals(true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.9444444444444444, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.0555555555555556, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.6666666666666666, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(3.375, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test01()
    {
        Bruch b1 = new Bruch(-8,-3);
        Bruch b2 = new Bruch(1,-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.5555555555555554, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.7777777777777777, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.2962962962962963, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-24.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test02()
    {
        Bruch b1 = new Bruch(6,-3);
        Bruch b2 = new Bruch(5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-7.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-10.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.4, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test03()
    {
        Bruch b1 = new Bruch(-3,-5);
        Bruch b2 = new Bruch(8,-7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.5428571428571428, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.7428571428571429, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.6857142857142857, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.525, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test04()
    {
        Bruch b1 = new Bruch(-1,-5);
        Bruch b2 = new Bruch(0,-8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.2, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.2, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test05()
    {
        Bruch b1 = new Bruch(-2,-2);
        Bruch b2 = new Bruch(-6,-3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test06()
    {
        Bruch b1 = new Bruch(8,2);
        Bruch b2 = new Bruch(1,-3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.6666666666666665, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(4.333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.3333333333333333, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-12.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test07()
    {
        Bruch b1 = new Bruch(0,-2);
        Bruch b2 = new Bruch(-3,-5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.6, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.6, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test08()
    {
        Bruch b1 = new Bruch(-5,3);
        Bruch b2 = new Bruch(0,-8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.6666666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.6666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test09()
    {
        Bruch b1 = new Bruch(2,2);
        Bruch b2 = new Bruch(3,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(2.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test10()
    {
        Bruch b1 = new Bruch(-4,-1);
        Bruch b2 = new Bruch(6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);

        assertEquals(10.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(24.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.6666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test11()
    {
        Bruch b1 = new Bruch(7,-7);
        Bruch b2 = new Bruch(5,4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.25, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.25, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.8, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test12()
    {
        Bruch b1 = new Bruch(-2,-8);
        Bruch b2 = new Bruch(-4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-3.75, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(4.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.0625, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test13()
    {
        Bruch b1 = new Bruch(2,5);
        Bruch b2 = new Bruch(2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.4, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.6, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.8, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test14()
    {
        Bruch b1 = new Bruch(7,1);
        Bruch b2 = new Bruch(-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(13.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-42.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.1666666666666667, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test15()
    {
        Bruch b1 = new Bruch(5,5);
        Bruch b2 = new Bruch(-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-2.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test16()
    {
        Bruch b1 = new Bruch(-8,-2);
        Bruch b2 = new Bruch(-2,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.75, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(4.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-16.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test17()
    {
        Bruch b1 = new Bruch(-9,-9);
        Bruch b2 = new Bruch(6,-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test18()
    {
        Bruch b1 = new Bruch(-3,5);
        Bruch b2 = new Bruch(-7,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.475, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.275, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.525, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.6857142857142857, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test19()
    {
        Bruch b1 = new Bruch(-3,-7);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.42857142857142855, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.42857142857142855, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test20()
    {
        Bruch b1 = new Bruch(-1,-5);
        Bruch b2 = new Bruch(0,-5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.2, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.2, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test21()
    {
        Bruch b1 = new Bruch(8,-2);
        Bruch b2 = new Bruch(-3,3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-5.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(4.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(4.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test22()
    {
        Bruch b1 = new Bruch(-8,6);
        Bruch b2 = new Bruch(-4,-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.6666666666666666, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.8888888888888888, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-2.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test23()
    {
        Bruch b1 = new Bruch(-5,-2);
        Bruch b2 = new Bruch(0,-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test24()
    {
        Bruch b1 = new Bruch(-8,9);
        Bruch b2 = new Bruch(-2,-8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.6388888888888888, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.1388888888888888, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.2222222222222222, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-3.5555555555555554, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test25()
    {
        Bruch b1 = new Bruch(0,-3);
        Bruch b2 = new Bruch(-3,-5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.6, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.6, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test26()
    {
        Bruch b1 = new Bruch(-3,-3);
        Bruch b2 = new Bruch(-2,-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.2222222222222223, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.7777777777777778, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.2222222222222222, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(4.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test27()
    {
        Bruch b1 = new Bruch(8,-6);
        Bruch b2 = new Bruch(8,7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.19047619047619047, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.4761904761904763, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.5238095238095237, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.1666666666666667, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test28()
    {
        Bruch b1 = new Bruch(-3,-6);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test29()
    {
        Bruch b1 = new Bruch(-4,2);
        Bruch b2 = new Bruch(1,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.875, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.125, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.25, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-16.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test30()
    {
        Bruch b1 = new Bruch(3,1);
        Bruch b2 = new Bruch(-1,-3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.3333333333333335, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.6666666666666665, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(9.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test31()
    {
        Bruch b1 = new Bruch(-3,-4);
        Bruch b2 = new Bruch(-1,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.625, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.875, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.09375, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-6.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test32()
    {
        Bruch b1 = new Bruch(7,6);
        Bruch b2 = new Bruch(-5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-3.8333333333333335, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(6.166666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-5.833333333333333, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.23333333333333334, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test33()
    {
        Bruch b1 = new Bruch(-2,1);
        Bruch b2 = new Bruch(8,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.6666666666666666, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.3333333333333335, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-2.6666666666666665, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test34()
    {
        Bruch b1 = new Bruch(9,3);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test35()
    {
        Bruch b1 = new Bruch(1,1);
        Bruch b2 = new Bruch(4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(5.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(4.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.25, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test36()
    {
        Bruch b1 = new Bruch(2,-7);
        Bruch b2 = new Bruch(-3,-7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.14285714285714285, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.7142857142857143, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.12244897959183673, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.6666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test37()
    {
        Bruch b1 = new Bruch(-8,-6);
        Bruch b2 = new Bruch(6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(7.333333333333333, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-4.666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(8.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2222222222222222, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test38()
    {
        Bruch b1 = new Bruch(5,4);
        Bruch b2 = new Bruch(8,4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.25, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.75, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.625, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test39()
    {
        Bruch b1 = new Bruch(-6,7);
        Bruch b2 = new Bruch(8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(7.142857142857143, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-8.857142857142858, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-6.857142857142857, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.10714285714285714, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test40()
    {
        Bruch b1 = new Bruch(6,6);
        Bruch b2 = new Bruch(7,5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.4, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.4, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(1.4, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.7142857142857143, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test41()
    {
        Bruch b1 = new Bruch(9,-9);
        Bruch b2 = new Bruch(9,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.6666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test42()
    {
        Bruch b1 = new Bruch(-8,7);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.1428571428571428, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.1428571428571428, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test43()
    {
        Bruch b1 = new Bruch(8,-2);
        Bruch b2 = new Bruch(8,-8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-5.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(4.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(4.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test44()
    {
        Bruch b1 = new Bruch(2,-9);
        Bruch b2 = new Bruch(8,-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.1111111111111112, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.6666666666666666, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.19753086419753085, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.25, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test45()
    {
        Bruch b1 = new Bruch(-8,-6);
        Bruch b2 = new Bruch(-1);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.3333333333333333, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.3333333333333335, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.3333333333333333, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.3333333333333333, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test46()
    {
        Bruch b1 = new Bruch(-9,6);
        Bruch b2 = new Bruch(4,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.8333333333333334, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.1666666666666665, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-2.25, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test47()
    {
        Bruch b1 = new Bruch(4,1);
        Bruch b2 = new Bruch(-3,9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.6666666666666665, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(4.333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.3333333333333333, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-12.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test48()
    {
        Bruch b1 = new Bruch(-1,-3);
        Bruch b2 = new Bruch(-7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-6.666666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(7.333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-2.3333333333333335, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.047619047619047616, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test49()
    {
        Bruch b1 = new Bruch(1,3);
        Bruch b2 = new Bruch(4,9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.7777777777777778, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.1111111111111111, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.14814814814814814, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.75, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test50()
    {
        Bruch b1 = new Bruch(-5,2);
        Bruch b2 = new Bruch(6,-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-5.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(7.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.8333333333333334, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test51()
    {
        Bruch b1 = new Bruch(8,-3);
        Bruch b2 = new Bruch(-5,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-3.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.8333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.2222222222222223, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(3.2, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test52()
    {
        Bruch b1 = new Bruch(-2,-6);
        Bruch b2 = new Bruch(6,-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-2.6666666666666665, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(3.3333333333333335, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.1111111111111111, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test53()
    {
        Bruch b1 = new Bruch(-8,1);
        Bruch b2 = new Bruch(7,1);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-15.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-56.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.1428571428571428, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test54()
    {
        Bruch b1 = new Bruch(-8,8);
        Bruch b2 = new Bruch(-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-3.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test55()
    {
        Bruch b1 = new Bruch(4,8);
        Bruch b2 = new Bruch(0,7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test56()
    {
        Bruch b1 = new Bruch(9,-2);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-4.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-4.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test57()
    {
        Bruch b1 = new Bruch(8,7);
        Bruch b2 = new Bruch(9,-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.14285714285714285, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.142857142857143, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.1428571428571428, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.1428571428571428, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test58()
    {
        Bruch b1 = new Bruch(-3,-6);
        Bruch b2 = new Bruch(3,2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.75, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.3333333333333333, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test59()
    {
        Bruch b1 = new Bruch(7,-4);
        Bruch b2 = new Bruch(-4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-5.75, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(7.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.4375, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test60()
    {
        Bruch b1 = new Bruch(-6,-5);
        Bruch b2 = new Bruch(-5,-3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.8666666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.4666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.72, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test61()
    {
        Bruch b1 = new Bruch(-7,-2);
        Bruch b2 = new Bruch(-6,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.75, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(4.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-2.625, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-4.666666666666667, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test62()
    {
        Bruch b1 = new Bruch(-8,7);
        Bruch b2 = new Bruch(-9,-7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.14285714285714285, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.4285714285714284, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-1.469387755102041, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.8888888888888888, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test63()
    {
        Bruch b1 = new Bruch(-2,7);
        Bruch b2 = new Bruch(-4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-4.285714285714286, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(3.7142857142857144, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(1.1428571428571428, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.07142857142857142, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test64()
    {
        Bruch b1 = new Bruch(-6,6);
        Bruch b2 = new Bruch(-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-7.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(5.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(6.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.16666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test65()
    {
        Bruch b1 = new Bruch(3,-9);
        Bruch b2 = new Bruch(-6,5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.5333333333333334, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.8666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.4, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2777777777777778, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test66()
    {
        Bruch b1 = new Bruch(-1,4);
        Bruch b2 = new Bruch(4,4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.75, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.25, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.25, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.25, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test67()
    {
        Bruch b1 = new Bruch(-8,-1);
        Bruch b2 = new Bruch(-1);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(7.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(9.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-8.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-8.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test68()
    {
        Bruch b1 = new Bruch(-7,1);
        Bruch b2 = new Bruch(-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-9.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-5.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(14.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(3.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test69()
    {
        Bruch b1 = new Bruch(-2,6);
        Bruch b2 = new Bruch(-1,4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.5833333333333334, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.08333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.08333333333333333, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(1.3333333333333333, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test70()
    {
        Bruch b1 = new Bruch(1,9);
        Bruch b2 = new Bruch(3,-5);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.4888888888888889, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.7111111111111111, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.06666666666666667, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.18518518518518517, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test71()
    {
        Bruch b1 = new Bruch(-5,2);
        Bruch b2 = new Bruch(-2,7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-2.7857142857142856, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.2142857142857144, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.7142857142857143, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(8.75, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test72()
    {
        Bruch b1 = new Bruch(-3,-7);
        Bruch b2 = new Bruch(-9,-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(4.928571428571429, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-4.071428571428571, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(1.9285714285714286, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.09523809523809523, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test73()
    {
        Bruch b1 = new Bruch(3,7);
        Bruch b2 = new Bruch(8,-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.9047619047619048, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.7619047619047619, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.5714285714285714, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.32142857142857145, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test74()
    {
        Bruch b1 = new Bruch(0,-7);
        Bruch b2 = new Bruch(3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test75()
    {
        Bruch b1 = new Bruch(9,2);
        Bruch b2 = new Bruch(6,-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(5.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-4.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-4.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test76()
    {
        Bruch b1 = new Bruch(-4,8);
        Bruch b2 = new Bruch(7,9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.2777777777777778, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.2777777777777777, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.3888888888888889, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.6428571428571429, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test77()
    {
        Bruch b1 = new Bruch(-5,6);
        Bruch b2 = new Bruch(-5,-1);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(4.166666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-5.833333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-4.166666666666667, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.16666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test78()
    {
        Bruch b1 = new Bruch(-9,-3);
        Bruch b2 = new Bruch(2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(5.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(6.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(1.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test79()
    {
        Bruch b1 = new Bruch(-1,1);
        Bruch b2 = new Bruch(0,4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-1.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test80()
    {
        Bruch b1 = new Bruch(-5,6);
        Bruch b2 = new Bruch(-9,3);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-3.8333333333333335, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.1666666666666665, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2777777777777778, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test81()
    {
        Bruch b1 = new Bruch(6,-9);
        Bruch b2 = new Bruch(-6,-6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(0.3333333333333333, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-1.6666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-0.6666666666666666, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.6666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test82()
    {
        Bruch b1 = new Bruch(8,8);
        Bruch b2 = new Bruch(9,-1);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-8.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(10.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-9.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.1111111111111111, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test83()
    {
        Bruch b1 = new Bruch(-1,7);
        Bruch b2 = new Bruch(-5,9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.6984126984126984, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.4126984126984127, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.07936507936507936, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2571428571428571, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test84()
    {
        Bruch b1 = new Bruch(5,3);
        Bruch b2 = new Bruch(0,-8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.6666666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(1.6666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test85()
    {
        Bruch b1 = new Bruch(7,2);
        Bruch b2 = new Bruch(0,8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(3.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(3.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test86()
    {
        Bruch b1 = new Bruch(9,9);
        Bruch b2 = new Bruch(9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(10.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-8.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(9.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.1111111111111111, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test87()
    {
        Bruch b1 = new Bruch(-1,-9);
        Bruch b2 = new Bruch(4);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(4.111111111111111, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.888888888888889, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.4444444444444444, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.027777777777777776, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test88()
    {
        Bruch b1 = new Bruch(-9,3);
        Bruch b2 = new Bruch(-8,-3);

        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.3333333333333333, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-5.666666666666667, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-8.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-1.125, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test89()
    {
        Bruch b1 = new Bruch(-9,-2);
        Bruch b2 = new Bruch(7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(11.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(31.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.6428571428571429, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test90()
    {
        Bruch b1 = new Bruch(4,9);
        Bruch b2 = new Bruch(-9);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-8.555555555555555, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(9.444444444444445, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-4.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.04938271604938271, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test91()
    {
        Bruch b1 = new Bruch(5,-5);
        Bruch b2 = new Bruch(-7,2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-4.5, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(2.5, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(3.5, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.2857142857142857, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test92()
    {
        Bruch b1 = new Bruch(6,-6);
        Bruch b2 = new Bruch(4,2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(1.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-2.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test93()
    {
        Bruch b1 = new Bruch(0,1);
        Bruch b2 = new Bruch(-2,6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-0.3333333333333333, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(0.3333333333333333, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test94()
    {
        Bruch b1 = new Bruch(6,-3);
        Bruch b2 = new Bruch(0);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-2.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-2.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(0.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
    }

    @Test
    public void test95()
    {
        Bruch b1 = new Bruch(-8,-5);
        Bruch b2 = new Bruch(6);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(7.6, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-4.4, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(9.6, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.26666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test96()
    {
        Bruch b1 = new Bruch(4,6);
        Bruch b2 = new Bruch(8,2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(4.666666666666667, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-3.3333333333333335, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(2.6666666666666665, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.16666666666666666, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test97()
    {
        Bruch b1 = new Bruch(6,-1);
        Bruch b2 = new Bruch(-2);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(-8.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-4.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(12.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(3.0, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test98()
    {
        Bruch b1 = new Bruch(-8,-8);
        Bruch b2 = new Bruch(-9,-7);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(2.2857142857142856, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-0.2857142857142857, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(1.2857142857142858, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(0.7777777777777778, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }

    @Test
    public void test99()
    {
        Bruch b1 = new Bruch(4,-1);
        Bruch b2 = new Bruch(8);
        assertEquals( true, b1.getNenner() > 0);
        assertEquals( true, b2.getNenner() > 0);
        Bruch ba = b1.addieren(b2);
        assertEquals(4.0, (double)ba.getZaehler()/ba.getNenner(),0.001);
        Bruch bs = b1.subtrahieren(b2);
        assertEquals(-12.0, (double)bs.getZaehler()/bs.getNenner(),0.001);
        Bruch bm = b1.multiplizieren(b2);
        assertEquals(-32.0, (double)bm.getZaehler()/bm.getNenner(),0.001);
        Bruch bd = b1.dividieren(b2);
        assertEquals(-0.5, (double)bd.getZaehler()/bd.getNenner(),0.001);
        int ggt1 = ggt(b1.getZaehler(), b1.getNenner());
        assertEquals(1, ggt1);
        int ggt2 = ggt(b2.getZaehler(), b2.getNenner());
        assertEquals(1, ggt2);
        int ggta = ggt(ba.getZaehler(), ba.getNenner());
        assertEquals(1, ggta);
        int ggts = ggt(bs.getZaehler(), bs.getNenner());
        assertEquals(1, ggts);
        int ggtm = ggt(bm.getZaehler(), bm.getNenner());
        assertEquals(1, ggtm);
        int ggtd = ggt(bd.getZaehler(), bd.getNenner());
        assertEquals(1, ggtd);
    }
}