Online java test ingångsnivå. Programtestning, JUnit. Java-testförutsättningar

Jag tror att mjukvaruutveckling är mer än ett jobb. Jag ser mig själv som en hantverkare som försöker bli bättre för varje dag. Det "enklaste" sättet att göra detta är att hitta några bra verktyg och svara på följande frågor:

• När ska jag använda Tool X?
• Hur ska jag använda verktyg X?

Automatiserad testning är en mycket viktig del av mjukvaruutveckling, men det finns få inlägg på programmerares bloggar om de verktyg som används. Samma artikel låter dig titta in i min "verktygslåda". Jag kommer att täcka 12 bibliotek och ramverk som jag använder för att skriva enhets- och integrationstester, och ge länkar till sidor som hjälper dig att förstå hur du använder dem.

Låt oss titta i min verktygslåda

Innan du kan använda verktygen som beskrivs nedan måste du konfigurera en build som automatiskt kör integration och enhetstester. Jag har 2 anteckningar om detta ämne:

• Integrationstestning med Maven beskriver hur vi kan sätta upp en Maven-build med integration och enhetstester i olika kataloger.
• Komma igång med Gradle: Integrationstestning med TestSets Plugin täcker samma sak för Gradle.

Nu är du redo att ta en närmare titt på mina verktyg. Jag har delat in dem i kategorier för att göra det lättare för dig att navigera.

Så här är 12 verktyg som jag använder för integration och enhetstestning.

Löpande tester

AssertJ tillhandahåller ett flexibelt API för att skriva påståenden med användbara felmeddelanden, förbättrar testkodens läsbarhet och låter dig förvandla tester till körbara specifikationer som följer det önskade domänspecifika språket.

Dessutom:

• Att använda Hamcrest i testning täcker hur man använder Hamcrest för att skriva tester, samt hur man utökar dess möjligheter med anpassade moduler.
• Att förvandla påståenden till ett domänspecifikt språk förklarar hur man skapar anpassade påståenden i AssertJ.
• Att skriva rena tester: Ersätta påståenden med domänspecifikt språk. Förklarar varför vi bör ersätta JUnits standardpåståenden med våra egna som använder rätt domänspecifikt språk.

Testning av dataåtkomstkod

Snabb databas, användbar för att skriva integrationstester som körs på lokal maskin utvecklare.

En tillägg till JUnit som kan användas för att initiera databasen till ett känt tillstånd innan man kör varje integrationstest och fylla databasen med nödvändig data. DbUnit har sina nackdelar, men det är mycket användbart verktyg, vilket gör att du kan separera testdata och testkod.

Dessutom:

• beskriver nyckelkomponenterna i DbUnit som du behöver känna till för att skriva tester med DbUnit.
• ger fem regler för att skriva de bästa testerna för dataåtkomstkod.

När jag letade efter testuppgifter för Java-programmerare, kom jag över en intressant sida (Avast-användare ska inte gå, en skripttrojan upptäcks, andra mår tydligen bra) - http://www.betterprogrammer.com. Det testar Java-programmerares kvalifikationer på det enklaste sättet, men på ett automatiskt sätt: erbjuder att skriva flera funktioner (metoder) med ökande komplexitet och kopiera koden till TextArea. Därefter gör platsmotorn något med uppgifterna (inte mindre än ett enhetstest), beräknar ett visst kvalifikationsindex baserat på kriterierna för "hastighetskvalitet" och ger slutresultatet i följande form:

Sedan börjar frågorna. Jag programmerade själv i Java för andra gången i mitt liv (och hoppade därför helt enkelt över komplexa uppgifter), så 82% på detta test motsvarar nivån icke-java programmerare. Hur mycket ska då Java Junior, Java Programmer och ännu mer Java Senior rekrytera?! Vilket resultat kan du förvänta dig av närvarande java programmerare - 90, 95, 99? Och slutligen, tänk om "programmeraren" får mindre än 82 poäng, men ändå ansöker om något slags jobb?!

Att testa är inte alltid roligt och intressant. Denna process är vanligtvis ganska lång och ibland full av monotont arbete. Det verkar som att programmerare nyligen använde standardutdata eller en debugger för att testa java-klasser.

I den här artikeln kommer jag att beskriva JUnit 4-biblioteket, som avsevärt förenklar och automatiserar processen att skriva tester.

För att demonstrera de viktigaste funktionerna i JUnit Framework, låt oss skriva en primitiv klass i Java och håna den. Denna klass kommer att ha två metoder - att hitta faktorialen för ett icke-negativt tal och summan av två tal. Dessutom kommer klassinstansen att innehålla en metodanropsräknare.

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

Låt oss nu skriva enhetstester. För att göra detta kommer vi att skapa en klass med ett antal testmetoder. Naturligtvis kan en klass även innehålla vanliga hjälpmetoder. För att testlöparen ska kunna avgöra vem som är vem måste testmetoder noteras med @Test.

En anteckning kan ha följande parametrar:

• förväntat - ange vilket undantag som kommer att genereras av metoden (se exempel nedan);
• timeout - efter vilken tid i millisekunder kommer testet att sluta köras och räknas som misslyckat.

Om du vill indikera att ett visst test ska hoppas över, markera det med @Ignorera-anteckningen. Även om du helt enkelt kan ta bort @Test-anteckningen.

Det kan finnas tillfällen då du behöver något sammanhang, till exempel förskapade klassinstanser, för att köra varje testfall. Och efter exekvering måste du släppa de reserverade resurserna. I det här fallet behöver du @Före och @Efter kommentarer. Metoden märkt @Before kommer att exekveras före varje testfall, och metoden märkt @After kommer att exekveras efter varje testfall.

Om initiering och frigöring av resurser bara behöver göras en gång - före respektive efter alla tester - använd då ett par anteckningar @BeforeClass och @AfterClass.

Och här är själva testklassen med flera testskript:

Public class MathFuncTest ( privat MathFunc math; @Before public void init() ( math = new MathFunc(); ) @After public void tearDown() ( math = null; ) @Test public void calls() ( assertEquals(0, math .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); ) @Ignorera @Test public void todo() ( assertTrue(math.plus(1, 1) == 3); ) )

Anropsmetoden testar anropsräknarens giltighet. Faktorialmetoden kontrollerar om factorialen är korrekt beräknad för vissa standardvärden. Metoden factorialNegative kontrollerar att ett IllegalArgumentException kommer att kastas för negativa faktorvärden. Att göra-metoden kommer att ignoreras. Försök att ta bort @Ignorera-kommentaren när du experimenterar med koden.

AssertTrue-metoden kontrollerar om resultatet av ett uttryck är sant. Några andra metoder som kan vara användbara:

• assertEquals - det förväntade resultatet och det mottagna resultatet matchar;
• assertNull - resultatet av uttrycket är null;
• assertNotNull - resultatet av uttrycket skiljer sig från null;
• assertSame - de förväntade och mottagna objekten är samma objekt.
• fail - metoden genererar ett AssertionError-undantag - vi lägger till det där programkörningen inte ska gå.

I vår modern värld IDE:er kan hitta och helt enkelt köra tester i ett projekt. Men vad händer om du vill köra dem manuellt med hjälp av programkod. För att göra detta kan du använda Runner.Det finns textversioner - junit.textui.TestRunner, grafiska versioner - junit.swingui.TestRunner, junit.awtui.TestRunner.

Men lite mer modern metodär användningen av klassen JUnitCore. Lägg till följande huvudmetod till MathFuncTest-klassen:

Public static void main(String args) kastar Undantag ( JUnitCore runner = new JUnitCore(); Resultatresultat = runner.run(MathFuncTest.class); System.out.println("kör tester: " + result.getRunCount()); System.out.println("misslyckade tester: " + result.getFailureCount()); System.out.println("ignorerade tester: " + result.getIgnoreCount()); System.out.println("framgång: " + resultat .Var framgångsrik()); )

Och exekveringsresultatet:

Kör tester: 3 misslyckade tester: 0 ignorerade tester: 1 framgång: sant

I mer tidigare versioner För att skriva en JUnit-testklass var det nödvändigt att skapa en ättling till junit.framework.TestCase. Sedan var det nödvändigt att definiera en konstruktor som tar en sträng som parameter - namnet på metoden - och skicka den till den överordnade klassen. Varje testmetod fick börja med prefixtestet. Installations- och tearDown-metoderna användes för att initiera och frigöra resurser. Kort sagt, skräck. Nåväl, nu är allt enkelt, ja.

Det är allt för idag. Jag är säker på att JUnit Framework kommer att hjälpa dig mycket. Kommentarer och frågor om artikeln är välkomna.