Hoe schrijf je een eenheidstest?

Ik heb een Java-klasse. Hoe kan ik het unit testen?

In mijn geval heb ik klasse doet een binaire som. Er zijn twee byte[]arrays nodig, ze worden opgeteld en een nieuwe binaire array geretourneerd.

Antwoord 1, autoriteit 100%

1. Definieer de verwachte en gewenste uitvoer voor een normaal geval, met de juiste invoer.

2. Implementeer nu de test door een klasse te declareren, noem het iets (meestal zoiets als TestAddingModule), en voeg de testAdd-methode eraan toe (d.w.z. zoals die hieronder):

   • Schrijf een methode en voeg daarboven de @Test-annotatie toe.
   • Voer in de methode uw binaire som en assertEquals(expectedVal,calculatedVal)uit.

   • Test uw methode door deze uit te voeren (klik in Eclipse met de rechtermuisknop, selecteer Uitvoeren als → JUnit-test).

     //for normal addition 
     @Test
     public void testAdd1Plus1() 
     {
         int x  = 1 ; int y = 1;
         assertEquals(2, myClass.add(x,y));
     }
     

3. Voeg desgewenst andere gevallen toe.

   • Test of je binaire som geen onverwachte uitzondering veroorzaakt als er een integer overflow is.

   • Test of uw methode Null-invoer netjes verwerkt (voorbeeld hieronder).

     //if you are using 0 as default for null, make sure your class works in that case.
     @Test
     public void testAdd1Plus1() 
     {
         int y = 1;
         assertEquals(0, myClass.add(null,y));
     }
     

Antwoord 2, autoriteit 90%

Ik lever dit bericht voor zowel IntelliJals Eclipse.

Verduistering:

Voor het maken van een unit-test voor uw project, volgt u deze stappen (ik gebruik Eclipse om deze test te schrijven):

1- Klik op Nieuw -> Java-project.

2- Schrijf je projectnaam op en klik op voltooien.

3- Klik met de rechtermuisknop op uw project. Klik vervolgens op Nieuw -> Klasse.

4- Schrijf je klasnaam op en klik op voltooien.

Voltooi de les dan als volgt:

public class Math {
    int a, b;
    Math(int a, int b) {
        this.a = a;
        this.b = b;
    }
    public int add() {
        return a + b;
    }
}

5- Klik op Bestand -> Nieuw -> JUnit-testcase.

6- Controleer setUp() en klik op voltooien. SetUp() is de plaats waar u uw test initialiseert.

7- Klik op OK.

8- Hier voeg ik eenvoudig 7 en 10 toe, dus verwacht ik het antwoord op 17. Voltooi je testklasse als volgt:

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class MathTest {
    Math math;
    @Before
    public void setUp() throws Exception {
        math = new Math(7, 10);
    }
    @Test
    public void testAdd() {
        Assert.assertEquals(17, math.add());
    }
}

9- Schrijf klik op uw testklasse in Package Explorer en klik op Uitvoeren als – & GT; Junit-test.

10- Dit is het resultaat van de test.

Intellij:
Merk op dat ik intelrij idee community 2020.1 heb gebruikt voor de schermafbeeldingen. Ook moet u uw JRE vóór deze stappen instellen. Ik gebruik JDK 11.0.4.

1 1 Klik met de rechtermuisknop op de hoofdmap van uw project- & GT; Nieuw – & GT; Directory. Je moet deze ‘test’ noemen.

2- Klik met de rechtermuisknop op de testmap en maak het juiste pakket. Ik stel voor om dezelfde verpakkingsnamen te maken als de originele klasse. Klik vervolgens met de rechtermuisknop op de testdirectory – & GT; Markeer Directory als – & GT; Testbronnen root.

3- In het juiste pakket in de testdirectory, moet u een Java-klasse maken (ik stel voor om test.java te gebruiken).

4- Typ in de aangemaakte klasse ‘@Test’. Selecteer vervolgens, onder de opties die IntelliJ u geeft, ‘JUnitx’ toevoegen aan klassenpad.


5- Schrijf je testmethode in je testklas. De handtekening van de methode is als volgt:

@Test
public void test<name of original method>(){
...
}

U kunt uw beweringen doen zoals hieronder:

Assertions.assertTrue(f.flipEquiv(node1_1, node2_1));

Dit zijn de importen die ik heb toegevoegd:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

Dit is de test die ik schreef:

U kunt uw methoden als volgt controleren:

Assertions.assertEquals(<Expected>,<actual>);
Assertions.assertTrue(<actual>);
...

Voor het uitvoeren van uw eenheidstests, klik met de rechtermuisknop op de test en klik op Uitvoeren .

Als uw test slaagt, ziet het resultaat er als volgt uit:

Ik hoop dat het helpt. Je kunt de structuur van het project zien in GitHub https://github.com/m-vahidalizadeh/problem_solving_project.

Antwoord 3, autoriteit 13%

Dit is een zeer algemene vraag en er zijn veel manieren waarop deze kan worden beantwoord.

Als u JUnit wilt gebruiken om de tests te maken, moet u uw testcaseklasse maken en vervolgens individuele testmethoden maken die specifieke functionaliteit van uw klasse/module testen onder tests (enkele testcaseklassen worden meestal geassocieerd met een enkele “productie ” class die wordt getest) en voer binnen deze methoden verschillende bewerkingen uit en vergelijk de resultaten met wat correct zou zijn. Het is vooral belangrijk om zoveel mogelijk hoekgevallen te bedekken.

In uw specifieke voorbeeld kunt u bijvoorbeeld het volgende testen:

1. Een simpele optelling tussen twee positieve getallen. Voeg ze toe en controleer vervolgens of het resultaat is wat je zou verwachten.
2. Een optelling tussen een positief en een negatief getal (dat een resultaat oplevert met het teken van het eerste argument).
3. Een optelling tussen een positief en een negatief getal (dat een resultaat oplevert met het teken van het tweede argument).
4. Een optelling tussen twee negatieve getallen.
5. Een toevoeging die resulteert in een overloop.

Om de resultaten te verifiëren, kunt u verschillende assertXXX-methoden uit de klasse org.junit.Assert gebruiken (voor het gemak kunt u ‘import static org.junit.Assert.*’ doen). Deze methoden testen een bepaalde conditie en slagen voor de test als deze niet valideert (met een specifiek bericht, optioneel).

Voorbeeld testcase klasse in jouw geval (zonder de methode inhoud gedefinieerd):

import static org.junit.Assert.*;
public class AdditionTests {
    @Test
    public void testSimpleAddition() { ... }
    @Test
    public void testPositiveNegativeAddition() { ... }
    @Test
    public void testNegativePositiveAddition() { ... }
    @Test
    public void testNegativeAddition() { ... }
    @Test
    public void testOverflow() { ... }
}

Als u niet gewend bent eenheidstests te schrijven, maar in plaats daarvan uw code test door ad-hoctests te schrijven die u vervolgens “visueel” valideert (u schrijft bijvoorbeeld een eenvoudige hoofdmethode die argumenten accepteert die met het toetsenbord zijn ingevoerd en vervolgens afdrukt de resultaten uit – en dan blijf je waarden invoeren en jezelf valideren als de resultaten correct zijn), dan kun je beginnen met het schrijven van dergelijke tests in het bovenstaande formaat en de resultaten valideren met de juiste assertXXX-methode in plaats van het handmatig te doen. Op deze manier kunt u de test veel gemakkelijker opnieuw uitvoeren dan wanneer u handmatige tests zou moeten doen.

Antwoord 4, autoriteit 5%

Zoals @CoolBeans al zei, neem een kijkje op jUnit. Hier is een korte zelfstudieom u ook op weg te helpen met jUnit 4.x

Ten slotte, als je echt meer wilt weten over testen en testgestuurde ontwikkeling (TDD), raad ik je aan het volgende boek van Kent Beck te bekijken: Test-Driven Development bij voorbeeld.