Online java test startnivå. Programtesting, JUnit. Java Test Forutsetninger

Jeg tror at programvareutvikling er mer enn en jobb. Jeg ser på meg selv som en håndverker som prøver å bli bedre hver dag. Den "enkleste" måten å gjøre dette på er å finne noen gode verktøy og svare på følgende spørsmål:

• Når bør jeg bruke Tool X?
• Hvordan bør jeg bruke verktøy X?

Automatisert testing er en svært viktig del av programvareutvikling, men det er få innlegg på blogger til programmerere om verktøyene som brukes. Denne samme artikkelen lar deg se inn i "verktøykassen min". Jeg skal dekke 12 biblioteker og rammeverk som jeg bruker til å skrive enhets- og integrasjonstester, og gi lenker til sider som vil hjelpe deg å forstå hvordan du bruker dem.

La oss se i verktøykassen min

Før du kan bruke verktøyene beskrevet nedenfor, må du sette opp en build som automatisk kjører integrasjon og enhetstester. Jeg har 2 merknader om dette emnet:

• Integrasjonstesting med Maven beskriver hvordan vi kan sette opp et Maven-bygg med integrasjon og enhetstester i forskjellige kataloger.
• Komme i gang med Gradle: Integrasjonstesting med TestSets Plugin dekker det samme for Gradle.

Nå er du klar til å se nærmere på verktøyene mine. Jeg har delt dem inn i kategorier for å gjøre det lettere for deg å navigere.

Så, her er 12 verktøy som jeg bruker for integrering og enhetstesting.

Kjører tester

AssertJ gir et fleksibelt API for å skrive påstander med nyttige feilmeldinger, forbedrer lesbarheten til testkoden og lar deg gjøre tester til kjørbare spesifikasjoner som overholder det ønskede domenespesifikke språket.

I tillegg:

• Bruk av Hamcrest i testing dekker hvordan du bruker Hamcrest til å skrive tester, samt hvordan du utvider mulighetene med tilpassede moduler.
• Å gjøre påstander om til et domenespesifikt språk forklarer hvordan du lager tilpassede påstander i AssertJ.
• Skrive rene tester: Erstatte påstander med domenespesifikt språk. Forklarer hvorfor vi bør erstatte JUnits standardpåstander med våre egne som bruker riktig domenespesifikt språk.

Testing av datatilgangskode

Rask database, nyttig for å skrive integrasjonstester som kjører på lokal maskin utvikler.

En utvidelse til JUnit som kan brukes til å initialisere databasen til en kjent tilstand før du kjører hver integrasjonstest og fylle databasen med nødvendige data. DbUnit har sine ulemper, men det er veldig nyttig verktøy, som lar deg skille testdata og testkode.

I tillegg:

• beskriver nøkkelkomponentene i DbUnit som du trenger å vite for å skrive tester med DbUnit.
• gir fem regler for å skrive de beste testene for datatilgangskode.

Mens jeg lette etter testoppgaver for Java-programmerere, kom jeg over et interessant nettsted (Avast-brukere bør ikke gå, en skripttrojaner oppdages, andre har det tilsynelatende bra) - http://www.betterprogrammer.com. Den tester kvalifikasjonene til Java-programmerere på den enkleste måten, men på en automatisk måte: tilbyr å skrive flere funksjoner (metoder) med økende kompleksitet og kopiere koden inn i TextArea. Deretter gjør nettstedsmotoren noe med oppgavene (ikke mindre enn en enhetstest), beregner en viss kvalifikasjonsindeks basert på "hastighetskvalitet"-kriteriene og gir den endelige poengsummen i følgende form:

Så begynner spørsmålene. Selv programmerte jeg i Java for andre gang i mitt liv (og hoppet derfor rett og slett over komplekse oppgaver), så 82% på denne testen tilsvarer nivået programmerer uten java. Hvor mye bør da Java Junior, Java Programmer og enda mer Java Senior rekruttere?! Hvilket resultat kan du forvente av tilstede java programmerer - 90, 95, 99? Og til slutt, hva om "programmereren" scorer mindre enn 82, men likevel søker på en slags jobb?!

Testing er ikke alltid morsomt og interessant. Denne prosessen er vanligvis ganske langvarig og noen ganger full av monotont arbeid. Det ser ut til at programmerere nylig brukte standard utgang eller en debugger for å teste java-klasser.

I denne artikkelen vil jeg beskrive JUnit 4-biblioteket, som i stor grad forenkler og automatiserer prosessen med å skrive tester.

For å demonstrere hovedfunksjonene til JUnit Framework, la oss skrive en primitiv klasse i Java og håne den. Denne klassen vil ha to metoder - å finne faktoren til et ikke-negativt tall og summen av to tall. I tillegg vil klasseforekomsten inneholde en metodekallteller.

Public class MathFunc ( int calls; public int getCalls() ( return calls; ) public long factorial(int number) ( calls++; if (nummer 1) ( for (int i = 1; i)

La oss nå skrive enhetstester. For å gjøre dette vil vi lage en klasse med en rekke testmetoder. Naturligvis kan en klasse også inneholde vanlige hjelpemetoder. For at testløperen skal avgjøre hvem som er hvem, må testmetodene merkes med @Test.

En merknad kan ha følgende parametere:

• forventet - angi hvilket unntak som vil genereres av metoden (se eksempel nedenfor);
• timeout - etter hvilken tid i millisekunder vil testen slutte å kjøre og regne den som mislykket.

Hvis du vil indikere at en bestemt test skal hoppes over, merk den med @Ignorer-kommentaren. Selv om du ganske enkelt kan fjerne @Test-kommentaren.

Det kan være tider når du trenger litt kontekst, for eksempel forhåndslagrede klasseforekomster, for å kjøre hver testcase. Og etter utførelse må du frigjøre de reserverte ressursene. I dette tilfellet trenger du @Før og @Etter merknader. Metoden merket @Before vil bli utført før hvert testtilfelle, og metoden merket @After vil bli utført etter hvert testtilfelle.

Hvis initialisering og frigjøring av ressurser bare må gjøres én gang - henholdsvis før og etter alle tester - så bruk et par merknader @BeforeClass og @AfterClass.

Og her er selve testklassen med flere testskript:

Offentlig klasse MathFuncTest ( privat MathFunc matte; @Before public void init() ( math = new MathFunc(); ) @Etter offentlig void tearDown() ( math = null; ) @Test offentlige void calls() ( assertEquals(0, matte) .getCalls()); math.fatorial(1); assertEquals(1, math.getCalls()); math.fatorial(1); assertEquals(2, math.getCalls()); ) @Test public void factorial() ( assertTrue(math.factorial(0) == 1); assertTrue(math.fatorial(1) == 1); assertTrue(math.fatorial(5) == 120); ) @Test(expected = IllegalArgumentException.class) public void factorialNegative() ( math.fatorial(-1); ) @Ignorer @Test public void todo() ( assertTrue(math.plus(1, 1) == 3); ) )

Samtalemetoden tester gyldigheten av samtaletelleren. Faktorialmetoden kontrollerer om faktorialet er riktig beregnet for noen standardverdier. FactorialNegative-metoden sjekker at et IllegalArgumentException vil bli kastet for negative faktorverdier. Todo-metoden vil bli ignorert. Prøv å fjerne @Ignorer-kommentaren når du eksperimenterer med koden.

AssertTrue-metoden sjekker om resultatet av et uttrykk er sant. Noen andre metoder som kan være nyttige:

• assertEquals - det forventede resultatet og det mottatte resultatet samsvarer;
• assertNull - resultatet av uttrykket er null;
• assertNotNull - resultatet av uttrykket er forskjellig fra null;
• assertSame - de forventede og mottatte objektene er det samme objektet.
• fail - metoden genererer et AssertionError-unntak - vi legger det til der programkjøringen ikke skal gå.

I vår moderne verden IDE-er kan finne og ganske enkelt kjøre tester i et prosjekt. Men hva om du vil kjøre dem manuelt ved å bruke programkode. For å gjøre dette kan du bruke Runner.Det finnes tekstversjoner - junit.textui.TestRunner, grafiske versjoner - junit.swingui.TestRunner, junit.awtui.TestRunner.

Men litt mer moderne metode er bruken av JUnitCore-klassen. Legg til følgende hovedmetode til MathFuncTest-klassen:

Offentlig statisk void main(String args) kaster Unntak ( JUnitCore runner = new JUnitCore(); Resultatresultat = runner.run(MathFuncTest.class); System.out.println("kjør tester: " + result.getRunCount()); System.out.println("mislykkede tester: " + result.getFailureCount()); System.out.println("ignorerte tester: " + result.getIgnoreCount()); System.out.println("suksess: " + resultat .hadde suksess()); )

Og utførelsesresultatet:

Kjør tester: 3 mislykkede tester: 0 ignorerte tester: 1 suksess: sant

I mer tidligere versjoner For å skrive en JUnit-testklasse var det nødvendig å lage en etterkommer av junit.framework.TestCase. Da var det nødvendig å definere en konstruktør som tar en streng som parameter – navnet på metoden – og sende den til overordnet klasse. Hver testmetode måtte starte med prefikstesten. Oppsett- og tearDown-metodene ble brukt til å initialisere og frigjøre ressurser. Kort sagt, skrekk. Vel, nå er alt enkelt, ja.

Det var alt for i dag. Jeg er sikker på at JUnit Framework vil hjelpe deg mye. Kommentarer og spørsmål om artikkelen er velkomne.