Plik app/java/pl.umk.fizyka.helloworld (test)/ExampleUnitTest
Uruchamianie testów: ikona "Run test" na lewym marginesie edytora (także Debug)
Wyniki w "Android Monitor"
Można zmienić nazwę pliku (jedna klasa - jeden plik)


------------------- Plik ExampleUnitTest.java -----------------------


package pl.umk.fizyka.helloworld;

import android.support.annotation.Nullable;

import org.junit.Test;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Random;

import static org.junit.Assert.*;

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
 */
public class ExampleUnitTest {

    private Random r = new Random();

    private int losujLiczbeCalkowita(int maksymalnaBezwzglednaWartosc) {
        maksymalnaBezwzglednaWartosc = Math.abs(maksymalnaBezwzglednaWartosc);
        return r.nextInt(maksymalnaBezwzglednaWartosc); //to tylko od zera!!!!!!!!!!!!!!!!!!!!!!!!!!!
    }

    private int losujLiczbeCalkowita() {
        return losujLiczbeCalkowita(Integer.MAX_VALUE);
    }

    private int losujLiczbeCalkowitaRoznaOdZera(int maksymalnaBezwzglednaWartosc) {
        int wartosc;
        do {
            wartosc = losujLiczbeCalkowita(maksymalnaBezwzglednaWartosc);
        }
        while (wartosc == 0);
        return wartosc;
    }

    private int losujLiczbeCalkowitaRoznaOdZera() {
        return losujLiczbeCalkowitaRoznaOdZera(Integer.MAX_VALUE);
    }

    @Test
    public void TestKonstruktoraIWlasnosci() throws UlamekMianownikRównyZeroException {
        //przygotowania (assert)
        int licznik = losujLiczbeCalkowita();
        int mianownik = losujLiczbeCalkowitaRoznaOdZera();

        //działanie (act)
        Ulamek u = new Ulamek(licznik, mianownik);

        //weryfikacja (assert)
        assertEquals("Niezgodność w liczniku", licznik, u.getLicznik());
        assertEquals("Niezgodność w mianowniku", mianownik, u.getMianownik());
    }

    @Test
    public void TestKonstruktora() throws UlamekMianownikRównyZeroException, NoSuchFieldException, IllegalAccessException {
        //przygotowania (assert)
        int licznik = losujLiczbeCalkowita();
        int mianownik = losujLiczbeCalkowitaRoznaOdZera();

        //działanie (act)
        Ulamek u = new Ulamek(licznik, mianownik);

        //weryfikacja (assert)
        Field poleLicznik = Ulamek.class.getDeclaredField("licznik");
        Field poleMianownik = Ulamek.class.getDeclaredField("mianownik");
        poleLicznik.setAccessible(true);
        poleMianownik.setAccessible(true);
        int u_licznik = poleLicznik.getInt(u);
        int u_mianownik = poleMianownik.getInt(u);
        assertEquals("Niezgodność w liczniku", licznik, u_licznik);
        assertEquals("Niezgodność w mianowniku", mianownik, u_mianownik);
    }

    @Test(expected = UlamekMianownikRównyZeroException.class)
    public void TestKonstruktoraWyjatek() throws UlamekMianownikRównyZeroException {
        Ulamek u = new Ulamek(losujLiczbeCalkowita(), 0);
    }

    @Test
    public void TestPolaStatycznegoPolowa() {
        Ulamek u = Ulamek.połowa;
        assertEquals(1, u.getLicznik());
        assertEquals(2, u.getMianownik());
    }

    @Test
    public void TestMetodyUprosc() {
        try {
            Ulamek u = new Ulamek(4, -2);

            u.uprość();

            assertEquals(-2, u.getLicznik());
            assertEquals(1, u.getMianownik());
        } catch (UlamekMianownikRównyZeroException exc) {
            return;
        }
    }

    @Test
    public void TestOperatorow() throws UlamekMianownikRównyZeroException
    {
        Ulamek a = Ulamek.połowa;
        Ulamek b = Ulamek.ćwierć;

        Ulamek suma_ab = Ulamek.suma(a, b); suma_ab.uprość();
        Ulamek suma_ba = Ulamek.suma(b, a); suma_ba.uprość();
        Ulamek różnica_ab = Ulamek.różnica(a, b); różnica_ab.uprość();
        Ulamek iloczyn_ab = Ulamek.iloczyn(a, b); iloczyn_ab.uprość();
        Ulamek iloczyn_ba = Ulamek.iloczyn(b, a); iloczyn_ba.uprość();
        Ulamek iloraz_ab = Ulamek.iloraz(a, b); iloraz_ab.uprość();

        assertEquals("Niepowodzenie przy dodawaniu - licznik", 3, suma_ab.getLicznik());
        assertEquals("Niepowodzenie przy dodawaniu - mianownik", 4, suma_ab.getMianownik());
        assertEquals("Niepowodzenie przy dodawaniu - licznik", 3, suma_ba.getLicznik());
        assertEquals("Niepowodzenie przy dodawaniu - mianownik", 4, suma_ba.getMianownik());
        assertEquals("Niepowodzenie przy odejmowaniu - licznik", 1, różnica_ab.getLicznik());
        assertEquals("Niepowodzenie przy odejmowaniu - mianownik", 4, różnica_ab.getMianownik());
        assertEquals("Niepowodzenie przy mnożeniu - licznik", 1, iloczyn_ab.getLicznik());
        assertEquals("Niepowodzenie przy mnożeniu - licznik", 8, iloczyn_ab.getMianownik());
        assertEquals("Niepowodzenie przy mnożeniu - licznik", 1, iloczyn_ba.getLicznik());
        assertEquals("Niepowodzenie przy mnożeniu - licznik", 8, iloczyn_ba.getMianownik());
        assertEquals("Niepowodzenie przy dzieleniu - licznik", 2, iloraz_ab.getLicznik());
        assertEquals("Niepowodzenie przy dzieleniu - mianownik", 1, iloraz_ab.getMianownik());
    }

    @Test
    public void TestSortowania() throws UlamekMianownikRównyZeroException
    {
        Ulamek[] tablica = new Ulamek[100];
        for (int i = 0; i < tablica.length; i++)
            tablica[i] = new Ulamek(losujLiczbeCalkowita(), losujLiczbeCalkowitaRoznaOdZera());

        Arrays.sort(tablica);

        Boolean tablicaJestPosortowanaRosnaco = true;
        for (int i = 0; i < tablica.length - 1; i++)
            if (!tablica[i].isLesserOrEqualThan(tablica[i + 1])) tablicaJestPosortowanaRosnaco = false;
        assertTrue(tablicaJestPosortowanaRosnaco);
    }

    @Test
    public void TestCompareTo() throws UlamekException {
        Ulamek u1 = new Ulamek(1,2);
        Ulamek u2 = new Ulamek(1,4);
        Ulamek u3 = new Ulamek(1,4);

        assertEquals("u1 > u2", 1, u1.compareTo(u2));
        assertEquals("u2 < u1", -1, u2.compareTo(u1));
        assertEquals("u2 = u3", 0, u2.compareTo(u3));
    }

    @Test
    public void testUprość() throws UlamekMianownikRównyZeroException {
        Ulamek u1 = new Ulamek(2, 4);
        u1.uprość();
        assertEquals("u1l", 1, u1.getLicznik());
        assertEquals("u1m", 2, u1.getMianownik());

        Ulamek u2 = new Ulamek(2, -4);
        u2.uprość();
        assertEquals("u2l", -1, u2.getLicznik());
        assertEquals("u2m", 2, u2.getMianownik());

        Ulamek u3 = new Ulamek(-2, -4);
        u3.uprość();
        assertEquals("u3l", 1, u3.getLicznik());
        assertEquals("u3m", 2, u3.getMianownik());

        Ulamek u4 = new Ulamek(2, -6);
        u4.uprość();
        assertEquals("u4l", -1, u4.getLicznik());
        assertEquals("u4m", 3, u4.getMianownik());
    }

    private final int liczbaPowtorzen = 100;
    private final double delta = 1E-10;

    @Test
    public void TestKonwersjiDoDouble() throws UlamekMianownikRównyZeroException
    {
        for (int i = 0; i < liczbaPowtorzen; ++i)
        {
            int licznik = losujLiczbeCalkowita();
            int mianownik = losujLiczbeCalkowitaRoznaOdZera();
            Ulamek u = new Ulamek(licznik, mianownik);

            double d = u.toDouble();

            assertEquals(licznik / (double)mianownik, d, delta);
        }
    }

    @Test
    public void TestKonwersjiZInt() throws UlamekMianownikRównyZeroException
    {
        for (int i = 0; i < liczbaPowtorzen; ++i)
        {
            int licznik = losujLiczbeCalkowita();

            Ulamek u = new Ulamek(licznik);

            assertEquals(licznik, u.getLicznik());
            assertEquals(1, u.getMianownik());
        }
    }

    @Test
    public void TestNWD()
    {
        assertEquals(2, Ulamek.nwd(2, 4));
        assertEquals(2, Ulamek.nwd(4, 2));
        assertEquals(25, Ulamek.nwd(50, 75));
        assertEquals(25, Ulamek.nwd(75, 50));
    }

    @Test
    public void TestMetodyUprosc_Losowy() throws UlamekMianownikRównyZeroException
    {
        for (int i = 0; i < liczbaPowtorzen / 10; ++i)
        {
            Ulamek u = new Ulamek(losujLiczbeCalkowita(), losujLiczbeCalkowitaRoznaOdZera());
            Ulamek kopia = u; //klonowanie

            u.uprość();

            assertTrue(u.getMianownik() > 0);
            assertEquals(kopia.toDouble(), u.toDouble(), delta);
        }
    }

    @Test
    public void TestSumy() throws UlamekMianownikRównyZeroException
    {
        Ulamek a = new Ulamek(17211, 12195);
        Ulamek b = new Ulamek(18701, 31035);

        double suma = Ulamek.suma(a, b).toDouble();

        assertEquals(a.toDouble() + b.toDouble(), suma, delta);
    }

    //alternatywnie można testować skrajne wartości z dziedziny
    @Test
    public void TestOperatorow_Losowy() throws UlamekMianownikRównyZeroException
    {
        int limit = (int)(Math.sqrt(Integer.MAX_VALUE / 2) - 1); //ograniczenie maksymalnej wartosci
        for (int i = 0; i < liczbaPowtorzen; ++i)
        {
            Ulamek a = new Ulamek(losujLiczbeCalkowita(limit), losujLiczbeCalkowitaRoznaOdZera(limit));
            Ulamek b = new Ulamek(losujLiczbeCalkowita(limit), losujLiczbeCalkowitaRoznaOdZera(limit));

            double suma = Ulamek.suma(a, b).toDouble();
            double różnica = Ulamek.różnica(a, b).toDouble();
            double iloczyn = Ulamek.iloczyn(a, b).toDouble();
            double iloraz = Ulamek.iloraz(a, b).toDouble();

            assertEquals("Niepowodzenie przy dodawaniu (" + i + ")", a.toDouble() + b.toDouble(), suma, delta);
            assertEquals("Niepowodzenie przy odejmowaniu (" + i + ")", a.toDouble() - b.toDouble(), różnica, delta);
            assertEquals("Niepowodzenie przy mnożeniu (" + i + ")", a.toDouble() * b.toDouble(), iloczyn, delta);
            assertEquals("Niepowodzenie przy dzieleniu (" + i + ")", a.toDouble() / b.toDouble(), iloraz, delta);
        }

    }
}