Online teszt java belépő szintű. Programteszt, JUnit. Java teszt előfeltételei

Úgy gondolom, hogy a szoftverfejlesztés több, mint egy munka. Kézművesnek látom magam, aki minden nap jobb lenni. Ennek "legegyszerűbb" módja, ha talál néhány jó eszközt, és válaszol a következő kérdésekre:

• Mikor használjam az X eszközt?
• Hogyan kell használni az X eszközt?

Az automatizált tesztelés nagyon fontos része a szoftverfejlesztésnek, de a programozói blogokon kevés bejegyzés található a használt eszközökről. Ugyanez a cikk lehetővé teszi, hogy betekintsen az "eszköztáramba". Kitérek 12 könyvtárra és keretrendszerre, amelyeket egység- és integrációs tesztek írásához használok, és hivatkozásokat biztosítok az oldalakra, amelyek segítenek megérteni a használatukat.

Vessünk egy pillantást az eszköztáramba

Az alább ismertetett eszközök használata előtt be kell állítania egy olyan buildet, amely automatikusan futtatja az integrációs és egységteszteket. 2 megjegyzésem van ehhez a témához:

• A Maven-nel végzett integrációs tesztelés leírja, hogyan állíthatunk be egy Maven buildet integrációval és egységtesztekkel külön könyvtárakban.
• A Gradle használatának első lépései: A TestSets beépülő modullal végzett integrációs tesztelés ugyanezt írja le a Gradle esetében.

Most készen áll arra, hogy közelebbről is szemügyre vegye eszközeimet. A könnyebb eligazodás érdekében kategóriákra osztottam őket.

Tehát itt van 12 eszköz, amelyet az integrációhoz és az egységtesztekhez használok.

Tesztek futtatása

Az AssertJ rugalmas API-t biztosít hasznos hibaüzeneteket tartalmazó állítások írásához, javítja a tesztkód olvashatóságát, és lehetővé teszi, hogy a teszteket végrehajtható specifikációkká alakítsa, amelyek megfelelnek a kívánt tartományspecifikus nyelvnek.

Ezen kívül:

• A Hamcrest for Testing használata elmagyarázza, hogyan használhatja a Hamcrestet tesztek írásához, és hogyan bővítheti azt egyéni modulokkal.
• Az állítások tartományspecifikus nyelvvé alakítása elmagyarázza, hogyan hozhat létre egyéni állításokat az AssertJ-ben.
• Tiszta tesztek írása: Az állítások helyettesítése tartományspecifikus nyelvvel. Elmagyarázza, miért kell a szabványos JUnit állításokat lecserélnünk a sajátunkra, amelyek a megfelelő tartományspecifikus nyelvet használják.

Adathozzáférési kód tesztelése

Gyors DB, hasznos a futó integrációs tesztek írásához helyi gép fejlesztő.

A JUnit kiterjesztése, amellyel az adatbázis ismert állapotba inicializálható, mielőtt minden egyes integrációs tesztet végrehajtana, és feltöltené az adatbázist a kívánt adatokkal. A DbUnitnak vannak hátrányai, de nagyon hasznos eszköz A, amely lehetővé teszi a tesztadatok és a tesztkód elkülönítését.

Ezen kívül:

• leírja a DbUnit legfontosabb összetevőit, amelyeket ismernie kell a tesztek DbUnit használatával írásához.
• öt szabályt ad az adathozzáférési kód legjobb tesztjeinek megírásához.

Java programozók tesztfeladatait keresve egy érdekes oldalra bukkantam (az Avast-felhasználók ne menjenek el, szkriptelt trójai program észlelhető, a többi láthatóan lehetséges) - http://www.betterprogrammer.com. A Java programozók képesítését a legegyszerűbb, de automatikusan: több, egyre bonyolultabb függvény (módszer) írását és a kód TextArea-ba másolását kínálja. Ezután az oldalmotor csinál valamit a feladatokkal (nem más, mint az egységteszt), kiszámít egy bizonyos minősítési indexet a "sebesség-minőség" kritériumok szerint, és ebben a formában adja meg a végső értékelést:

Ezután kezdődnek a kérdések. Jómagam életemben másodszor programoztam Java nyelven (és ezért csak kihagytam az összetett feladatokat), így ezen a teszten 82% megfelel a szintnek nem java programozó. Mennyit kell akkor kapnia a Java Juniornak, a Java Programmernek és még inkább a Java Seniornak? Milyen eredményre számíthatunk ajándék Java programozó - 90, 95, 99? És végül mi van akkor, ha a "programozó" 82-nél kevesebb pontot ér el, de mégis jelentkezik valamilyen állásra?!

A tesztelés nem mindig szórakoztató és érdekes. Ez a folyamat általában meglehetősen hosszadalmas, és néha tele van monoton munkával. Úgy tűnik, hogy nemrég a programozók szabványos kimenetet vagy hibakeresőt használtak a java osztályok tesztelésére.

Ebben a cikkben leírom a JUnit 4 könyvtárat, amely nagyban leegyszerűsíti és automatizálja a tesztírás folyamatát.

A JUnit Framework főbb jellemzőinek bemutatásához írjunk egy primitív osztályt Java nyelven, és gúnyoljuk ki. Ennek az osztálynak két módszere lesz: egy nem-negatív szám faktoriálisának és két szám összegének meghatározása. Ezenkívül az osztálypéldány tartalmazni fog egy metódushívás-számlálót is.

Nyilvános osztály MathFunc ( int hívások; nyilvános int getCalls() ( visszatérő hívások; ) nyilvános hosszú faktoriális (int szám) ( hívások++; if (1) ( for (int i = 1; i

Most pedig írjunk Unit teszteket. Ehhez hozzunk létre egy osztályt számos tesztmódszerrel. Természetesen egy osztály tartalmazhatja a szokásos helper metódusokat is. Annak érdekében, hogy a tesztfutó megállapíthassa, ki kicsoda, a tesztmódszereket a @Test annotációval kell ellátni.

Az annotáció a következő paraméterekkel rendelkezhet:

• várt - adja meg, hogy melyik kivételt dobja a metódus (lásd az alábbi példát);
• timeout – ezredmásodpercben mennyi idő elteltével le kell állítani a tesztvégrehajtást, és sikertelennek kell tekinteni.

Ha azt szeretné jelezni, hogy egy bizonyos tesztet ki kell hagyni, akkor kommentálja az @Ignore megjegyzéssel. Bár egyszerűen eltávolíthatja a @Test megjegyzést.

Előfordulhat, hogy az egyes tesztforgatókönyvek végrehajtásához szükség van valamilyen kontextusra, például előre létrehozott osztálypéldányokra. És a végrehajtás után fel kell szabadítania a fenntartott erőforrásokat. Ebben az esetben szüksége lesz a @Before és @After megjegyzésekre. A @Before-val jelölt metódus minden teszteset előtt, egy @After-vel jelölt metódus pedig minden teszteset után kerül végrehajtásra.

Ha az erőforrások inicializálását és felszabadítását csak egyszer kell elvégezni - minden teszt előtt és után -, akkor használjon @BeforeClass és @AfterClass megjegyzéspárt.

És itt van maga a tesztosztály több tesztszkripttel:

Nyilvános osztály MathFuncTest ( privát MathFunc math; @A public void init() előtt ( math = new MathFunc(); ) @After public void tearDown() ( math = null; ) @Test public void calls() ( assertEquals(0, math) .getCalls()); math.factorial(1); assertEquals(1, math.getCalls()); math.factorial(1); assertEquals(2, math.getCalls()); ) @Test public void factorial() ( assertTrue(math.factorial(0) == 1); assertTrue(math.factorial(1) == 1); assertTrue(math.factorial(5) == 120); ) @Test(expected = IllegalArgumentException.class) public void factorialNegative() ( math.factorial(-1); ) @Ignore @Test public void todo() ( assertTrue(math.plus(1, 1) == 3); ) )

A calls metódus a hívásszámláló helyességét teszteli. A faktoriális módszer ellenőrzi, hogy a faktoriális kiszámítása helyes-e bizonyos standard értékekre. A factorialNegative metódus ellenőrzi, hogy a rendszer egy IllegalArgumentException kivételt dobjon a facotrial negatív értékeire. A todo metódust figyelmen kívül hagyja. Fontolja meg az @Ignore megjegyzés eltávolítását a kóddal való kísérletezés során.

Az assertTrue metódus ellenőrzi, hogy egy kifejezés eredménye igaz-e. Néhány egyéb módszer, ami jól jöhet:

• assertEquals - a várt eredmény és a kapott eredmény megegyezik;
• assertNull - a kifejezés eredménye null;
• assertNotNull - a kifejezés eredménye nem null;
• assertSame - a várt és fogadott objektumok ugyanazok az objektumok.
• sikertelen - a metódus AssertionError kivételt generál - hozzáadjuk oda, ahol a programvégrehajtás nem érheti el.

Miénkben modern világ Az IDE-k megtalálhatják és könnyen futtathatják a teszteket egy projektben. De mi van akkor, ha manuálisan szeretné futtatni őket programkóddal. Ehhez használhatja a Runner "th. Vannak szöveges - junit.textui.TestRunner, grafikus változatok - junit.swingui.TestRunner, junit.awtui.TestRunner.

De még egy kicsit modern módszer a JUnitCore osztály használata. Adja hozzá a következő fő metódust a MathFuncTest osztályhoz:

Public static void main(String args) kivételt dob ​​( JUnitCore runner = new JUnitCore(); Result result = runner.run(MathFuncTest.class); System.out.println("tesztek futtatása: " + result.getRunCount()); System.out.println("sikertelen tesztek: " + result.getFailureCount()); System.out.println("figyelmen kívül hagyott tesztek: " + result.getIgnoreCount()); System.out.println("siker: " + eredmény .sikeres volt()); )

És a végrehajtás eredménye:

Tesztek futtatása: 3 sikertelen teszt: 0 figyelmen kívül hagyott teszt: 1 sikeres: igaz

A JUnit korábbi verzióiban tesztosztály írásához létre kellett hozni egy junit.framework.TestCase alosztályt. Ezután egy olyan konstruktort kellett definiálni, amely paraméterként vesz egy String-et - a metódus nevét - és átadja a szülőosztálynak. Minden vizsgálati módszernek a teszt előtaggal kellett kezdődnie. A setUp és a tearDown módszereket használták az erőforrások inicializálására és felszabadítására. Röviden: horror. Nos, most már minden egyszerű, igen.

Ez minden mára. Biztos vagyok benne, hogy a JUnit Framework sokat fog segíteni. Várjuk a cikkel kapcsolatos megjegyzéseket és kérdéseket.