Szoftvertesztelés Alaptörvényei — JUnit 5 Vizsgafelkészítő

// 11 törvény

Az Alaptörvények

Kattints egy kártyára a szabály, a kódpélda és a magyarázat megtekintéséhez. Minden törvény közvetlenül a feltöltött tesztosztályokból van levezetve.

// specifikáció elemzés

Specifikáció Elemzése

3 valós vizsgafeladat mondatról mondatra — mi következik az egyes mondatokból, milyen tesztet kell hozzá írni és miért.

Teljes specifikáció

Egy pizzáról tároljuk a nevét (String), méretét cm-ben (24, 32, 50) és bruttó árát (int, Ft)! Legyen lehetőség a nevét módosítani! Helytelen méret esetén PizzaMeretException, helytelen ár esetén PizzaArException keletkezzen (mindkettő checked)! Hozzunk létre 4 Pizza objektumot (2 érvényes, 2 érvénytelen), és az érvényeseket tároljuk listában! Hozzunk létre toString() metódust! Írjuk ki a listában szereplő pizzák átlagárát!

"Egy pizzáról tároljuk a nevét, méretét (24, 32, 50 cm), bruttó árát! Legyen lehetőség a nevét módosítani!"

3 adattagot tárolunk → 3 getter teszt. A névhez setNev() is specifikált → azt is teszteljük. setNev() egyszerű setter, nincs exception, nincs try-catch.

Tesztek:

getNev()assertEquals — String érték egyezés04

getMeret()assertEquals — int méret egyezés04

getBruttoAr()assertEquals — int ár egyezés04

setNev()assertEquals — nincs exception, egyszerű setter04

@Test @Order(1)
void getNevTest() {
    Assertions.assertEquals("Pizza", p1.getNev(), "Hiba a getNev() metódus működésében!");
}
@Test @Order(2)
void getMeretTest() {
    Assertions.assertEquals(50, p4.getMeret(), "Hiba a getMeret() metódus működésében!");
}
@Test @Order(3)
void getBruttoArTest() {
    Assertions.assertEquals(2500, p1.getBruttoAr(), "Hiba a getBruttoAr() metódus működésében!");
}
@Test @Order(4)
void setNevTest() {
    p1.setNev("Kukorica");
    Assertions.assertEquals("Kukorica", p1.getNev(), "Hiba a setNev() metódus működésében!");
}

"Helytelen méret esetén PizzaMeretException, helytelen ár esetén PizzaArException keletkezzen!"

Két saját checked exception — minden setterhez 2-2 teszteset: érvényes értékre ne dobjon (try + assertEquals + catch fail()), érvénytelen értékre dobjon (A-minta: fail() a try-ben, catch üres).

Tesztek:

setMeret — érvényes értéktry + assertEquals + catch fail() — ne dobjon02

setMeret — érvénytelen értékA-minta: fail() try-ben, catch üres02

setBruttoAr — érvényes értéktry + assertEquals + catch fail() — ne dobjon02

setBruttoAr — érvénytelen értékA-minta: fail() try-ben, catch üres02

@Test @Order(5)
void setMeretHelyesErtekTest() {
    try {
        p4.setMeret(24);
        Assertions.assertEquals(24, p4.getMeret(), "Hiba a setMeret() működésében!");
    } catch (PizzaMeretException pme) {
        fail("Érvényes értéknél nem dobhat kivételt!");
    }
}
@Test @Order(6)
void setMeretRosszErtekTest() {
    try {
        p4.setMeret(2); // nem megengedett méret
        fail("Érvénytelen értéknél kivételt kellett volna dobni!");
    } catch (PizzaMeretException pme) { }
}
@Test @Order(7)
void setBruttoArHelyesErtekTest() {
    try {
        p1.setBruttoAr(4000);
        Assertions.assertEquals(4000, p1.getBruttoAr(), "Hiba a setBruttoAr() működésében!");
    } catch (PizzaArException pae) {
        fail("Érvényes értéknél nem dobhat kivételt!");
    }
}
@Test @Order(8)
void setBruttoArRosszErtekTest() {
    try {
        p1.setBruttoAr(-4000);
        fail("Negatív árnál kivételt kellett volna dobni!");
    } catch (PizzaArException pae) { }
}

"Hozzunk létre 4 Pizza objektumot (2 érvényes, 2 érvénytelen)! Az érvényeseket tároljuk listában!"

A @BeforeAll-ban try-catch blokkokkal hozzuk létre az objektumokat. Érvényes adat → bekerül a listába. Érvénytelen adat → kivétel dobódik, az objektum null marad. Nincs külön assertNull/assertNotNull teszt — a listára és a getterekre támaszkodunk.

Tesztek:

@BeforeAll — nem @Test!nincs direkt teszteset, ez csak setup — az objektumokat a getter/setter/toString tesztek használják01

private static Pizza p1, p2, p3, p4;
private static ArrayList<Pizza> pizzak;

@BeforeAll
static void beforeAll() {
    pizzak = new ArrayList<>();
    // érvényes → listába kerül
    try { p1 = new Pizza("Pizza",   24, 2500); pizzak.add(p1); }
    catch (PizzaMeretException pme) { } catch (PizzaArException pae) { }

    try { p4 = new Pizza("Szalami", 50, 6000); pizzak.add(p4); }
    catch (PizzaMeretException pme) { } catch (PizzaArException pae) { }

    // érvénytelen → kivétel dobódik, változó null marad, listába nem kerül
    try { p2 = new Pizza("X", 900, 300);   pizzak.add(p2); } // rossz méret
    catch (PizzaMeretException pme) { } catch (PizzaArException pae) { }

    try { p3 = new Pizza("Y", 32, -2000);  pizzak.add(p3); } // negatív ár
    catch (PizzaMeretException pme) { } catch (PizzaArException pae) { }
}

"Hozzunk létre toString() metódust!"

toString tesztelése: először üres String-gel futtasd le, a megbukott teszt actual értékét másold ki és illeszd be. Figyelj: a korábbi @Order-es setter tesztek módosíthatták az objektum állapotát — a toString az aktuális értékeket tükrözi!

Tesztek:

toString()assertEquals — teljes String pontos egyezés05

@Test @Order(9)
void toStringTest() {
    // p1 állapota a setter tesztek után: nev="Kukorica", meret=24, bruttoAr=4000
    Assertions.assertEquals(
        "Pizza{nev: 'Kukorica', meret: 24 cm, bruttoAr: 4000 Ft}",
        p1.toString(),
        "Hiba a toString() metódus működésében!"
    );
}

"Írjuk ki a listában szereplő pizzák átlagárát!"

Az átlag double → assertEquals-nál kötelező a delta (0.1). Ha nincs külön atlagAr() metódus, a tesztben is kiszámolhatod ciklussal. A listában lévő pizzák ára változhat a setter tesztek miatt — ellenőrizd az aktuális értékeket!

Tesztek:

atlagAr / inline kiszámításassertEquals + delta 0.1 — double értéknél mindig!06

@Test @Order(10)
void atlagTest() {
    // pizzak: p1 (bruttoAr = 4000) + p4 (bruttoAr = 6000) → átlag = 5000.0
    // Ha van atlagAr() metódus a Pizza osztályon:
    // Assertions.assertEquals(5000.0, p1.atlagAr(pizzak), 0.1, "Hiba: átlag");
    // Ha nincs, inline számítás:
    double osszeg = 0;
    for (int i = 0; i < pizzak.size(); i++) {
        osszeg += pizzak.get(i).getBruttoAr();
    }
    Assertions.assertEquals(5000.0, osszeg / pizzak.size(), "Hiba az átlag számításában!");
}

Összes teszteset: ~10

Teljes specifikáció

Hozzon létre Szoveg osztályt, amely megvalósítja a Feldolgozo interfészt! Az atalakit() metódus a szöveget 10 karakterenként sortöréssel egészítse ki! Valósítsa meg az atalakit(int sorhossz) overloadolt metódust, amely a megadott sorhossz alapján helyez el sortöréseket! Definiáljon void tisztit() metódust, amely eltávolítja a fehér karaktereket és csupa kisbetűssé alakítja a szöveget!

"Az atalakit() metódus a szöveget 10 karakterenként sortöréssel egészítse ki!"

Határérték-analízis: ≤ 10 karakter → nincs sortörés, > 10 karakter → van. Fontos: a @BeforeAll-ban minden tesztesethez külön objektumot hozzunk létre, hogy ne befolyásolják egymást!

Tesztek:

atalakit() — ≤ 10 karakterassertEquals — nincs \n az eredményben09

atalakit() — > 10 karakterassertEquals — \n jelenik meg az eredményben09

// Minden teszthez saját objektum a @BeforeAll-ban!
private static Szoveg sz, sz3;
@BeforeAll
static void beforeAll() {
    sz  = new Szoveg("alma");                    // 4 karakter — nincs sortörés
    sz3 = new Szoveg("12345678901234567890123");  // 23 karakter — lesz sortörés
    // ... (sz2, sz4, sz5 a többi teszthez)
}

@Test
void atalakitTesztParameternelkulRovid() {
    Assertions.assertEquals("alma", sz.atalakit(),
        "Az atalakit() nem megfelelő rövid szöveg esetén!");
}
@Test
void atalakitTesztParameternelkulHosszu() {
    String er = "1234567890
1234567890
123";
    Assertions.assertEquals(er, sz3.atalakit(),
        "Az atalakit() nem megfelelő hosszú szöveg esetén!");
}

"Valósítsa meg az atalakit(int sorhossz) overloadolt metódust!"

Ugyanolyan határérték-tesztelés, de most a paraméter szabja meg a sorhosszt. Más objektumokon teszteljük mint az atalakit()-t — ezért kell a @BeforeAll-ban külön példányosítani.

Tesztek:

atalakit(int) — ≤ sorhosszassertEquals — nincs sortörés09

atalakit(int) — > sorhosszassertEquals — sortörés a paraméter szerint09

// @BeforeAll-ban: sz4 = new Szoveg("alma"); sz5 = new Szoveg("alma");
@Test
void atalakitTesztParameterrelRovid() {
    Assertions.assertEquals("alma", sz4.atalakit(5),
        "Az atalakit(hossz) nem megfelelő rövid szöveg esetén!");
}
@Test
void atalakitTesztParameterrelHosszu() {
    // sz5 = "alma", sorhossz = 1 → minden karakter külön sorba kerül
    String er = "a
l
m
a";
    Assertions.assertEquals(er, sz5.atalakit(1),
        "Az atalakit(hossz) nem megfelelő hosszú szöveg esetén!");
}

"Definiáljon void tisztit() metódust: eltávolítja a fehér karaktereket és kisbetűssé alakítja!"

Void metódus → meghívjuk, majd getterrel ellenőrizzük az eredményt. Nincs exception → try-catch nélkül. Érdemes szóközökkel és nagybetűkkel teli szöveget használni tesztadatként.

Tesztek:

tisztit()assertEquals — getSzoveg() kisbetűs, trimelt értéket ad04

// @BeforeAll-ban: sz2 = new Szoveg("      Alma             ");
@Test
void tisztitTeszt() {
    sz2.tisztit(); // void — nincs visszatérési érték
    Assertions.assertEquals("alma", sz2.getSzoveg(),
        "A tisztit() metódus működése nem megfelelő!");
}

Összes teszteset: ~5

Teljes specifikáció

Hozzon létre Butor osztályt, amely tárolja a bútor szélességét, magasságát, mélységét (egész, cm) és megnevezését (String)! Valósítson meg másoló konstruktort: a másolat megnevezése az eredeti nevéből és az "_masolat" utótagból álljon! Negatív méretérték esetén IllegalArgumentException keletkezzen! Valósítson meg toString() metódust! getTerfogat() adja vissza a bútor térfogatát (szélesség × magasság × mélység)! getOsszterfogat(lista) összesítse a listában szereplő bútorok térfogatát!

"Valósítson meg másoló konstruktort: a megnevezés az eredeti névből és az '_masolat' utótagból álljon!"

Másoló konstruktor → egy tesztmetódusban ellenőrizzük az összes adattagot (4 assertEquals egymás után). Nincs checked exception → a @BeforeAll-ban try-catch nélkül példányosítunk.

Tesztek:

masoloKonstruktorTeszt()4 assertEquals egy metódusban — mind a 4 adattagot ellenőrizzük04

private static Butor b1, b2;

@BeforeAll
static void beforeAll() {
    // Nincs checked exception → try-catch nélkül!
    b1 = new Butor(1, 1, 1, "Asztal");
    b2 = new Butor(b1); // másoló konstruktor
}

@Test
void masoloKonstruktorTeszt() {
    Assertions.assertEquals("Asztal_masolat", b2.getMegnevezes(), "Hiba a másoló konstruktor névbeállításakor!");
    Assertions.assertEquals(1, b2.getSzelesseg(), "Hiba a másoló konstruktor szélességbeállításakor!");
    Assertions.assertEquals(1, b2.getMagassag(),  "Hiba a másoló konstruktor magasságbeállításakor!");
    Assertions.assertEquals(1, b2.getMelyseg(),   "Hiba a másoló konstruktor mélységbeállításakor!");
}

"Negatív méretérték esetén IllegalArgumentException keletkezzen!"

IllegalArgumentException = unchecked exception → @BeforeAll-ban nem kell try-catch. A teszteléshez itt a B-mintát alkalmazzuk: return a catch-ben, fail() a try-catch után — szemantikailag pontosabb, mint az A-minta.

Tesztek:

negativKonstruktorTesztB-minta: return a catch-ben, fail() a try-catch után02

@Test
void negativKonstruktorTeszt() {
    try {
        Butor b = new Butor(-1, -1, -1, "Asztal");
    } catch (IllegalArgumentException iae) {
        return; // B-minta: kivétel keletkezett → teszt sikeres, visszatérünk
    }
    fail("Nem keletkezett IllegalArgumentException negatív méretek esetén!");
}

"Valósítson meg toString() metódust!"

toString tesztelése: először üres String-gel futtasd le, a megbukott teszt actual értékét másold ki és illeszd be az expected helyére.

Tesztek:

toString()assertEquals — teljes String pontos egyezés05

@Test
void toStringTeszt() {
    Assertions.assertEquals(
        "Szélesség: 1, Magasság: 1, Mélység: 1, Megnevezés: Asztal",
        b1.toString(),
        "Hiba a toString() működésében!"
    );
}

"getTerfogat() adja vissza a bútor térfogatát! getOsszterfogat(lista) összesítse a listában szereplő bútorok térfogatát!"

Mindkettő double visszatérési értékű → assertEquals-nál kötelező a delta (0.1). A getOsszterfogat() a listában lévő összes bútor térfogatát összeadja.

Tesztek:

getTerfogat()assertEquals + delta 0.1 — double értéknél mindig06

getOsszterfogat(lista)assertEquals + delta 0.1 — összesített double06

@Test
void getTerfogatTeszt() {
    // b1 = Butor(1, 1, 1, ...) → 1 × 1 × 1 = 1.0
    Assertions.assertEquals(1.0, b1.getTerfogat(), 0.1, "Hiba a getTerfogat() működésében!");
}

@Test
void getOsszterfogatTeszt() {
    ArrayList<Butor> butorok = new ArrayList<>();
    butorok.add(b1);
    butorok.add(b2); // b2 is Butor(1,1,1,...) → terfogat = 1.0
    // b1 + b2 → 1.0 + 1.0 = 2.0
    Assertions.assertEquals(2.0, Butor.getOsszterfogat(butorok), 0.1, "Hiba a getOsszterfogat() működésében!");
}

Összes teszteset: ~5

// interaktív kvíz

Teszteld a Tudásod

Melyik törvényt kell alkalmazni az adott szituációban? Azonnali visszajelzés, pontszám nyilvántartás.

PONTSZÁM

0 / 10

// tippek

Vizsgatippek

💡 toString() gyors megírása: Először üres Stringgel írd meg a tesztet, futtasd le, és a megbukott teszt kimenetéből másold ki az actual értéket — illeszd be az assertEquals-ba. Nem kell kézzel begépelni.
📊 Figyelj a pontozásra: Valószínűleg ahány pont van egy feladatnál, annyi teszteset kell — érdemes ebből visszaszámolni, hogy mit várnak el.
📋 Elemezd először a specifikációt: Mielőtt nekiállsz kódolni, olvasd végig mit kell tesztelni — dob-e kivételt, double-e az érték, van-e tömb. Utána válaszd ki a megfelelő törvényt.
⚠️ Ha a konstruktor kivételt dob, az objektum null marad: Mielőtt gettereket vagy settereket tesztelsz, bizonyosodj meg róla hogy az objektum tényleg létrejött a @BeforeAll-ban — különben NullPointerException-t kapsz futásidőben.
🔢 @Order számokban hagyj rést: Ne 1, 2, 3... hanem 1, 4, 7, 9... sorrendet használj — így ha utólag közé kell illeszteni egy tesztet, nem kell az összes számot átírni.
🔍 Checked vagy unchecked exception? Ha a konstruktor nem dob checked exceptiont (pl. Butor), a @BeforeAll-ban nem kell try-catch — egyenesen példányosítasz. Csak checked exception esetén kell a try-catch blokk.
✏️ A fail() üzenete legyen informatív: Ne csak "hiba" — írd bele mi a probléma és mikor keletkezik, pl. "Hiba a setMeret() működésében, érvényes értéknél kivétel keletkezett!". Vizsgán ez mutatja hogy érted a tesztet.

// leadás előtt

Leadás Előtti Ellenőrzőlista

Futtasd végig ezt a listát mielőtt beadod a dolgozatot.

Minden assert-nek van üzenet (message) paramétere
Minden double értékben van tizedes rész — nem 4.0 hanem 4.7, és mindenhol meg van adva a delta (0.1)
Minden kivételt megvizsgáltál — érvénytelen értékre dob, érvényes értékre nem dob
Mindenhol a helyzetnek megfelelő assertiont használtad (szám/String → assertEquals, tömb → assertArrayEquals, objektumazonosság → assertSame, null → assertNull / assertNotNull)