Med JUnit-dummies

JUnit är en standardiserad ram för att testa Java-enheter (det vill säga Java-klasser). JUnit kan automatiseras för att ta del av arbetet ur testning.

Tänk dig att du har skapat en enumtyp med tre värden: GRÖN, GUL och RÖD. Listning 1 innehåller koden:

Listing 1

Public Enum SignalColor {GREEN, YELLOW, RED}

Ett trafikljus har ett tillstånd (vilket är ett fint namn för trafikljusets färg).

allmän klass TrafficLight {SignalColor state = SignalColor. RÖD;

Om du känner till trafikljusets nuvarande tillstånd kan du bestämma vad trafikljusets nästa tillstånd kommer att vara.

public void nextState () {switch (state) {fall RED: state = SignalColor. GRÖN; ha sönder; fall GUL: state = SignalColor. RÖD; ha sönder; fall GREEN: state = SignalColor. GUL; ha sönder; standard: state = SignalColor. RÖD; break;}}

Du kan också ändra trafikljusets tillstånd ett visst antal gånger:

Offentlig tomgångsförändring (int numberOfTimes) {för (int i = 0; i 
Om du har allt ihop har du TrafficLight-klassen i lista 2.

Lista 2
allmän klass TrafficLight {SignalColor state = SignalColor. RÖD; public void nextState () {switch (state) {fall RED: state = SignalColor. GRÖN; ha sönder; fall GUL: state = SignalColor. RÖD; ha sönder; fall GREEN: state = SignalColor. GUL; ha sönder; standard: state = SignalColor. RÖD; break}} public void change (int numberOfTimes) {för (int i = 0; i 
I gamla dagar kan du ha fortsatt skrivkod, skapa fler klasser, ringa nästaState och ändra metoder i Listing 2. Sedan, efter flera månader av kodning, skulle du pausa för att testa ditt arbete.






Och vilken överraskning! Dina test skulle misslyckas eländigt! Du bör aldrig fördröja testning för mer än en dag eller två. Testa tidigt och testa ofta!
En filosofi om testning säger att du ska testa varje bit av kod så snart du har skrivit den. Självklart låter inte uttrycket "bit av kod" mycket vetenskapligt. Det skulle inte göra att utvecklare gick runt och pratade om "chunk-of-code testing" som de gjorde i eftermiddag. Det är bättre att ringa varje bit av kod en enhet och få utvecklare att prata om enhetstestning .
Den vanligaste testenheten är en klass. Så en typisk Java-utvecklare testa varje klass så snart klassens kod är skriven.
Så hur går det att testa en klass? En nybörjare kan testa TrafficLight-klassen genom att skriva en ytterligare klass - en klass som innehåller en huvudmetod. Huvudmetoden skapar en förekomst av TrafficLight, kallar NextState och ändrar metoder och visar resultaten.Nybörjaren undersöker resultaten och jämför dem med några förväntade värden.
Efter att ha skrivit huvudmetoder för dussintals, hundratals eller till och med tusentals klasser blir nybörjaren (nu en fullfjädrad utvecklare) trött på testrutinen och letar efter sätt att automatisera testproceduren. Trött eller inte, en utvecklare kan försöka dechiffrera en annan utvecklares handkodade test. Utan att ha några standarder eller riktlinjer för konstruktion av test, kan läsning och förståelse vara en annan utvecklings test kan vara svår och tråkig.
Så JUnit kommer till undsättning!.
Gör så här om hur Eclipse automatiserar användningen av JUnit, gör så här:


Skapa ett Eclipse-projekt som innehåller listor 1 och 2.



Högerklicka på paketfönstret TrafficLight i Windows. java filial. På en Mac, kontrollera-klicka på Paket Explorer Explorer TrafficLight. java filial.
En snabbmeny visas.


På snabbmenyn väljer du Ny → JUnit Test Case.
Som ett resultat visas dialogrutan Ny JUnit Test Case.



Klicka på Nästa längst ner i dialogrutan Ny JUnit Test Case.
Som ett resultat ser du den andra sidan i dialogrutan New JUnit Test Case. På den andra sidan visas metoder som hör till (antingen direkt eller indirekt) till TrafficLight-klassen.



Placera en kryssmarkering i kryssrutan Traffic Light.
Som ett resultat placerar Eclipse kryssrutor i kryssrutorna nextState () och change (int) .


Klicka på Slutför längst ner i dialogrutan Ny JUnit Test Case.
JUnit är inte formellt en del av Java. I stället kommer med sin egen uppsättning klasser och metoder för att hjälpa dig att skapa test för din kod. När du klickar på Finish frågar Eclipse dig om du vill inkludera JUnit-klasserna och metoderna som en del av ditt projekt.



Välj Utför följande åtgärd och lägg till JUnit 4-biblioteket till byggvägen. Klicka sedan på OK.
Eclipse stänger dialogrutorna och ditt projekt har en helt ny TrafficLightTest. java-fil. Filens kod visas i Listing 3.
Koden i Listning 3 innehåller två tester, och båda testerna innehåller samtal till en obehaglig ljudfelmetod. Eclipse vill att du ska lägga till kod för att göra dessa tester passerade.


Ta bort samtalen till felmetoden. I stället för misslyckningsmetodsamtal skriver du in koden som visas i fetstil i Listing 4.


Högerklicka (i Windows) eller Pack-klicka (på en Mac) TrafficLightTest i paketutforskaren. java filial. På den resulterande kontextmenyn väljer du Kör som → JUnit Test.
Eclipse kan ha mer än en typ av JUnit-testramar upp på ärmen. Om så är fallet kan du se en dialogruta som den nedan. Om du gör det väljer du Eclipse JUnit Launcher och klickar sedan på OK.

Som ett resultat körs Eclipse din TrafficLightTest. java program. Eclipse visar resultatet av körningen framför sin egen Package Explorer. Resultatet visar inga fel och inga fel. Puh!




Lista 3
importera statisk org. junit. Hävda. *; import org. junit. Testa; public class TrafficLightTest {@Test public void testNextState () {misslyckas ("Ännu inte implementerat");} @Test public void testChange () {fail ("Ej implementerat");}}


Listing 4
import statisk org.junit. Hävda. *; import org. junit. Testa; offentlig klass TrafficLightTest {@Test public void testNextState () { TrafficLight light = nytt TrafficLight (); assertEquals (SignalColor. RED, Light. State); ljus. nextState (); assertEquals (SignalColor. GREEN, light. State); ljus. nextState (); assertEquals (SignalColor. GUL, lätt tillstånd); ljus. nextState (); assertEquals (SignalColor. RED, Light. State); } @Test public void testChange () { TrafficLight light = nytt TrafficLight (); ljus. förändring (5); assertEquals (SignalColor. GUL, lätt tillstånd); }}

När du väljer Kör som → JUnit-test söker Eclipse inte efter en huvudmetod. Istället letar Eclipse efter metoder som börjar med @Test och andra sådana saker. Eclipse exekverar var och en av @Test-metoderna.
Saker som @Test är Java annoteringar .
Listning 4 innehåller två @Test metoder: testNextState och testChange. Metoden testNextState sätter TrafficLight NextState-metoden på provet. På samma sätt bjuder testChange-metoden på TrafficLight-förändringsmetodens muskler.
Tänk på koden i testNextState-metoden. TestNextState-metoden upprepade gånger kallar TrafficLight-klassens NextState-metod och JUnits assertEquals-metod. AssertEquals-metoden tar två parametrar: ett förväntat värde och ett verkligt värde.


I det högsta assertEquals call är det förväntade värdet SignalColor. RÖD. Du förväntar dig att trafikljuset är RÖTT, eftersom du i Listing 2 initierar ljusets tillstånd med värdet SignalColor. RÖD.


I det högsta assertEquals-samtalet är det faktiska värdet ljus. state (den färg som faktiskt lagras i trafikljusets tillståndsvariabel).


Om det verkliga värdet är lika med det förväntade värdet, fortsätter samtalet till assertEquals och JUnit fortsätter att utföra uttalandena i testNextState-metoden.
Men om det verkliga värdet skiljer sig från det förväntade värdet, misslyckas assertEquals och resultatet av körningen visar felet. Tänk på vad som händer när du ändrar det förväntade värdet i det första assertEquals-samtalet i Listing 4:
@Test public void testNextState () {TrafficLight light = new TrafficLight (); assertEquals (SignalColor. GUL, lätt tillstånd);

Omedelbart efter byggandet är trafikljusets färg RÖD, inte GUL. Så testNextState-metoden innehåller en falsk påstående och resultatet av att göra Run As → JUnit ser ut som ett barns dåliga rapportkort.

Att ha testNextState before testVisa i Listing 4 garanterar inte att JUnit ska utföra testNextState innan körning testChange. Om du har tre @Test-metoder kan JUnit utföra dem från översta till nedersta, från lägsta till högsta, från mellanmetod till översta eller nedersta eller i någon ordning alls. JUnit kan till och med pausa mitt i ett test för att utföra delar av ett annat test. Därför borde du aldrig göra antaganden om resultatet av ett test när du skriver ett annat test.
Du kanske vill att vissa uttalanden ska utföras innan någon av testerna börjar.Om du gör det, sätt dessa uttalanden i en metod som heter setUp, och förord ​​den metoden med en @För annotering. (Se kryssrutan setUp () i figuren i steg 3 i Listning 2 ovan.)
Här är nyheter: Inte alla påståEvalsmetoder skapas lika! Tänk dig att lägga till en förarklass för ditt projekts kod. "Drivarklass" betyder inte en skrivardrivrutin eller en stapeldrivrutin. Det betyder en person som kör bil - en bil som närmar sig ditt trafikljus. För detaljer, se Lista 5.

Lista 5
Public Class Driver {allmän dubbel hastighet (TrafficLight-ljus) {switch (ljusstatus) {fall RÖD: returnera 0. 0; fall GUL: retur 10 0; fall GREEN: return 30 0; standard: return 0. 0;}}}

När ljuset är rött är förarens hastighet 0. 0. När ljuset är gult sänker bilen till en säker 10. 0. När ljuset är grönt, Bilen kryssar med en hastighet av 30 0.
(I detta exempel spelar hastighetsenheterna ingen roll. De kan vara miles per timme, kilometer per timme eller vad som helst. Bilen ligger i Boston eller New York. I så fall bör hastigheten för GULV vara mycket högre än hastigheten för GRÖN, och hastigheten för RÖD bör inte vara 0. 0.)
För att skapa JUnit-tester för Förarklass, följ steg 1 till 9 som anges tidigare i den här artikeln, men var noga med att göra följande ändringar:


Högerklicka eller högerklicka på drivrutinen i steg 2. java filial istället för TrafficLight. java filial.


I steg 5 lägger du en kryssmarkering i drivrutinsgrenen.


I steg 8, ta bort felmetoderna samtal för att skapa DriverTest-klassen som visas i Listing 6. (Koden du skriver visas med fetstil.)



Listing 6
Importera statisk org. junit. Hävda. *; import org. junit. Testa; public class DriverTest {@Test public void testVelocity () { TrafficLight light = nytt TrafficLight (); ljus. förändring (7); Förare drivrutin = ny drivrutin (); assertEquals (30, 0, förare. Hastighet (ljus), 0. 1); }}

Om allt går bra passerar JUnit-testet med flygande färger. (För att vara mer exakt, passerar JUnit med färgen grön!) Så körningen av DriverTest är inte ny eller spännande. Vad som är spännande är att man kallar för att göra Equals i Listing 6.
När du jämför två dubbla värden i ett Java-program, har du ingen rätt att förvänta dig på näsan. Det vill säga ett av dubbelvärdena kan vara 30 000000000 medan det andra dubbelvärdet är närmare 30 000000001. En dator har bara 64 bitar för att lagra varje dubbelvärde och felaktigheter kryper in här och där. Så i JUnit har assertEquals metod för att jämföra dubbla värden en tredje parameter. Den tredje parametern representerar wiggle room.
I lista 6 anger uttalandet
assertEquals (30, 0, drivhastighet (ljus), 0. 1);

säger följande: "Anger att det faktiska värdet för föraren. hastighet (ljus) ligger inom 0. 1 av det förväntade värdet 30. 0. Om så är fallet, övergår försäkran. Om inte, misslyckas påståendet. "
När du kallar assertEquals för dubbla värden kan det vara svårt att välja en bra felmarginal.Dessa figurer illustrerar vilka saker som kan gå fel.

Här är din felmarginal för liten.

Där är din felmarginal för stor.
Lyckligtvis, i detta DriverTest-exempel är marginalen 0. 1 en mycket säker satsning. Här är varför:


När assertEquals-testet misslyckas misslyckas det med mycket mer än 0. 1. 
Fel betyder att ha en förare. hastighet (ljus) värde såsom 0. 0 eller 10. 0.



I det här exemplet, när assertEquals-testet passerar, representerar det förmodligen fullständig jämnhet på näsan. 
Förarens värde. hastighet (ljus) kommer direkt från retur 30. 0-kod i Lista 5. Ingen aritmetik är inblandad. Så värdet av föraren. hastighet (ljus) och det förväntade 30 0-värdet bör vara exakt samma (eller nästan exakt samma).