Hva er JUnit?
cherami
JUnit er en åpen kildekode Java testing rammeverket brukes til å skrive og kjøre repeterbare tester.Han er et system av xUnit enhetstesting rammene for en instans (for java språk).Den inneholder følgende funksjoner:
1, for testing forventede resultater av påstanden (Assertion)
2, for å dele felles test data testverktøy
3, for bekvemmeligheten av organisering og drift av test suite testene
4, grafikk og tekst test runner
JUnit ble opprinnelig utviklet av Erich Gamma (GOF One) og Kent Beck (xp og en av pionerene refactor) utarbeidet.
Bør bemerkes at JUnit er vanligvis brukt til enhetstesting, og derfor trenger å forstå den interne strukturen i koden som testes (såkalt white-box testing), den andre er xp JUnit programmering og refactoring (refactor) ble sterkt anbefaltverktøy, automatisk enhetstesting fordi forholdene kan i stor grad effektivisere utviklingen, men faktum er skriftlig test kode tar mye tid og krefter, så fordelene med å bruke denne ting Hvor er det?Jeg tror det er denne:
1, for xp programmering, oppfordrer til å skrive tester før du skriver kode, noe som kan tvinge deg til å tenke riktig før du skriver koden i koden (metoder) av funksjon og logikk, eller skrive koden er ustabil, så du trenger og samtidig opprettholdetest kode og selve koden, vil denne arbeidsbelastningen øke betydelig.Derfor, i xp programmering, er den grunnleggende prosessen dette: ideen - "skrive test kode -" å skrive kode - "test, og skriver tester og skrive kode er inkrementell, og skrive en liten test som kode i utarbeidelsen av fremtidigeHvis problemene finnes flere blokker kan spores tilbake til problemet, redusere vanskelig å rette feilen retur
2, for gjenoppbygging, er dens fordeler og xp programmering lignende, fordi gjenoppbygging er også nødvendig å endre en liten test, mindre tidkrevende på grunn returnere feil.
3, for ikke-over to situasjoner, når vi utvikler riktig bruk av skriver JUnit test er nødvendig, fordi den generelle tester vi også trenger å skrive kode, kan du ikke bruke den originale JUnit, hvis du bruker JUnit, men også motInterface (metoder) å forberede teste koden vil redusere fremtidig vedlikehold, for eksempel endringer i metoden etter (dette tilsvarer gjenoppbyggingsarbeidet.)JUnit påstand fordi det er en annen funksjon, hvis testresultatene ikke består testen vil fortelle oss at ikke pass, hvorfor, og hvis forrige generelle praksisen er å skrive noen teste koden er å se på produksjonen sin, og deretter å bestemme selv resultatene av å bruke riktigbruker JUnit fordel er at dette resultatet er riktig å dømme det å fullføre, trenger vi bare å se på det rett til å fortelle oss om resultatene kan, generelt, vil kraftig forbedre effektiviteten.
JUnit Komme i gang
cherami ordre
Installere JUnit
Installasjonen er veldig enkel, først følgende adresse for å laste ned en ny zip-pakke:
http://download.sourceforge.net/junit/
Etter lastet ned, pakke til din favoritt-katalogen, er forutsetningen JUNIT_HOME, så JUNIT_HOME junit.jar under pakken lagt til systemet CLASSPATH miljøvariabelen, for IDE miljøet, behovet for økt bruk av JUnit-prosjektetlib, sine forskjellige IDE innstillinger ha forskjellige innstillinger, der ikke mye å si.
Slik bruker JUnit å skrive tester?
Det enkleste eksempelet:
1, skaper en underklasse av TestCase:
pakke junitfaq;
import java.util .*;
import junit.framework .*;
public class SimpleTest strekker TestCase {
offentlig SimpleTest (String navn) {
super (navn);
}
2, skriver en testmetode hevder de forventede resultatene:
public void testEmptyCollection () {
Samling samlingen = ny ArrayList ();
assertTrue (collection.isEmpty ());
}
Merk: JUnit test tilnærming er anbefalt som begynnelsen på metoden som skal testes, slik at disse metodene kan bli automatisk funnet av testing.
3, skriv en suite ()-metoden, som bruker refleksjon som dynamisk oppretter en metode som inneholder alle de testXxxx test suite:
public static Test suite () {
Avkastningen nye TestSuite (SimpleTest.class);
}
4, skriv en main ()-metoden for å kjøre tekstmodus enheten for å lette driften av testen:
public static void main (String args []) {
junit.textui.TestRunner.run (suite ());
}
}
5, kjøre testen:
Kjør i tekstmodus:
java junitfaq.SimpleTest
Gjennom testresultatene er:
.
Tid: 0
OK (1 tester)
Time sier testen på antall små poeng, og dersom testing viser OK.Ellers viser den lille poenget bak merket F, at testen mislyktes.
Hver av testresultatene skal være OK, så for å forklare testen er vellykket, dersom mislykket informasjonen vil umiddelbart følge instruksjonene revidert.
JUnit test rapporten hvis ikke lykkes, vil det skille mellom feil (feil) og feil (feil).Svikt er koden i metoden din ikke grunn til å hevde, og feilen skyldes unormal kode, for eksempel ArrayIndexOutOfBoundsException.
Grafisk kjøre:
java junit.swingui.TestRunner junitfaq.SimpleTest
Testen resultater gjennom det grafiske grensesnittet til den grønne linjen delvis.
Disse de mest enkle prøven, selve testen, tester vi funksjonen til en klasse er ofte nødvendig å utføre enkelte vanlige operasjoner, etter gjennomføringen av ødeleggelsen av de ressursene som trengs (for eksempel nettverkstilkoblinger, database tilkoblinger, lukke åpne fileretc.), gir TestCase klasse oss et oppsett metode og tearDown metoder, oppsett metode for å teste innholdet i utarbeidelsen av TestCase underklasse metoden før hver testXxxx vil kjøre, og tearDown metoder for innhold etter utløpet av hver metode vil bli utført testXxxx.Den delte initialisering koden bare, men eliminerer også potensialet mellom hver test kode interaksjon.
JUnit beste praksis
Martin Fowler sa: "Når du prøver å skrive ut noen informasjon eller debugging et uttrykk, skriver noen test kode for å erstatte de tradisjonelle metoder." Først, vil du oppdage at du alltid vil opprette noen nye Fixture, og testenprogrammering ser ut til å senke tempoet.Kort tid etter, men vil du oppdage at du gjentar de samme Fixture, og den nye testen er vanligvis bare innebærer å legge en ny testmetode.
Du kan skrive mye test-kode, men du fort finne ut at du ser bare en liten del av testen er veldig nyttig.Du må teste er testen som vil mislykkes, at du tror vil ikke svikte disse testene, eller tror du de bør ikke testen av suksess.
Som vi nevnte tidligere testing er en prosess uten avbrudd.Når du har en test, bør du sørge for at deres arbeid har vært å teste arbeidet ved å legge nye koden.Ikke kjør med få dagers eller den siste testen dagen, bør du kjøre denne testen koden.Denne investeringen er svært liten, men det kan arbeide for å sikre at du får pålitelige kode.Reduser omarbeiding rente, vil du har mer tid til å skrive arbeider koden.
Tror ikke det presset, ikke skriv test kode.I stedet skrive test-kode vil gradvis redusere stress, bør testes ved å skrive kode, har du eksakte oppførselen til klassens forståelse.Du vil være raskere å skrive kode for å arbeide effektivt.
Her er noen spesifikke ferdigheter i skriftlig test kode eller god praksis:
En. Bruk ikke TestCase konstruktør initialiserer Fixture, men heller bruke setup () og tearDown ()-metoden.
2. Ikke stol på eller anta at rekkefølgen på testkjøringer, fordi JUnit test metode med Vector lagret.Så ulike plattformer vil være i en annen rekkefølge, fjerne fra Vector testmetoder.
Tre. For å unngå bivirkninger av utarbeidelse av en TestCase.For eksempel: Hvis etterfølgende tester avhenger av den spesifikke transaksjonen data, ikke sender inn transaksjonsdata.Vil bare rulle på den.
4. Når arve en test klasse, husk å ringe superklassen setup () og tearDown ()-metoden.
5. Vil teste koden og arbeider koden sammen, samtidig samle og oppdatere.(Bruke JUnit Ant måtte støtte oppgaven.)
6. Test klasser og testmetoder skal ha en konsekvent navneskjema.Hvis arbeiderklassen navnet med testen å danne testen klassenavnet.
7. For å sikre at testen er uavhengig av tid, ikke stole på utdatert data som brukes for testing.Resulterte i den påfølgende vedlikehold av prosessen er vanskelig å gjengi testen.
8. Hvis du skriver programvare for det internasjonale markedet, til utarbeidelse av testen vurdere når internasjonale faktorer.Native Locale ikke bare for testing.
9. Så mye som mulig å gi arealbruk JUnit hevder / ikke bestått metoden og metoden for håndtering av unntak kan gjøre koden mer konsis.
10. Testen å være så liten som mulig, gjennomføringen av fart.
Kombinasjon av JUnit og maur
cherami Lenker
maur har to mål: JUnit og junitreport
Kjør alle testtilfeller, og generere html-formatert rapport
Å gjøre følgende:
En. ANT_HOMElib katalog på junit.jar
. 2 Endre build.xml, legge til følgende:
property name="report" value="report" / target name="junitreport" depends="clean, compile" JUnit printsummary = "på" gaffel = "sanne "haltonfailure =" false "failureproperty =" tests.failed "showoutput =" true " classpath refid="myclasspath"/ formatter type="xml"/ batchtest todir = "$ {rapporten}" fileset dir="${build}" Include name="**/*Test.*"/ /fileset / batchtest / JUnit junitreport todir="${report}" fileset dir="${report}" inkluderer name = "TEST-*. xml "/ / fileset report format="frames" todir="${report}"/ / junitreport mislykkes hvis =" tests.failed "; --------------------------------------------------------- En eller flere tester feilet, se rapporten for detaljer ... --------------------------------------------------------- / mislykkes / target
Kjør dette målet, vil ant kjøre hver TestCase
Directory i rapporten er det mye TEST *. xml og noen sider
Åpne rapporten katalogen index.html du kan se en veldig intuitivt test kjøre rapporter på et øyeblikk.