Junit Assert & Assert liknar med exempel

Vad är Junit Assert?

Assert är en metod som är användbar för att avgöra om ett testfall är godkänt eller misslyckat. Assert-metoderna tillhandahålls av klassen org.junit.Assert, som utökar klassen java.lang.Object.

Det finns olika typer av påståenden, som booleska, null, identiska, etc.

JUnit tillhandahåller en klass med namnet Assert, som tillhandahåller en mängd assertion-metoder som är användbara för att skriva testfall och upptäcka testfel.

Assertmetoderna tillhandahålls av klassen org.junit.Assert, vilket förlänger java.lang.Object klass.

JUnit hävda metoder

Boolean

Om du vill testa de booleska villkoren (sant eller falskt) kan du använda följande assert-metoder:

1. assertTrue(condition)
2. hävdaFalse(villkor)

Här är tillståndet ett booleskt värde.

Noll objekt

Om du vill kontrollera initialvärdet för ett objekt/variabel har du följande metoder:

1. assertNull(objekt)
2. assertNotNull(objekt)

Här är objektet ett Java objekt, t.ex assertNull(faktisk);

Identisk

Om du vill kontrollera om objekten är identiska (dvs. jämföra två referenser till samma Java objekt) eller olika:

1. assertSame(förväntat, faktiskt) — Den returnerar sant om förväntat == faktisk.
2. hävdaNotSame(förväntad, faktisk)

Påstå lika

Om du vill testa likheten mellan två objekt har du följande metod:

• assertEquals(expected, real)

Det kommer att återkomma sant om förväntat.lika med (faktiskt) returnerar sant.

Assert Array Equals

Om du vill testa arrayernas likhet har du följande metod:

• assertArrayEquals(expected, actual)

Metoden ovan måste användas om arrayer har samma längd. För varje giltigt värde för i, kan du kontrollera det enligt nedan:

• assertEquals(förväntat[i], faktiskt[i])
• assertArrayEquals(förväntat[i], faktiskt[i])

Felmeddelande

Om du vill kasta något påståendefel har du det misslyckas(), vilket alltid resulterar i ett underkänt beslut.

• misslyckas (meddelande);

Du kan ha en assertionmetod med ytterligare Sträng parameter som den första parametern. Denna sträng läggs till i felmeddelandet om kontrollen misslyckas. Till exempel, misslyckas (meddelande) kan skrivas som:

• assertEquals(meddelande, förväntat, faktiskt)

JUnit assertEquals

Du har hävdaLika med(a, b), som förlitar sig på är lika med () metod för klassen Object.

• Här kommer det att utvärderas som a.lika med(b).
• Här används klassen som testas för att fastställa ett lämpligt jämställdhetsförhållande.
• Om en klass inte åsidosätter är lika med () metod för Ändamålet klassen, kommer den att få standardbeteendet för är lika med () metod, dvs. objektidentitet.

If a och b är primitiver som t.ex bitgrupp, int, boolean, etc., så kommer följande att göras för assertEquals(a, b):

a och b kommer att konverteras till motsvarande omslagsobjekttyp (Byte, heltal, booleskt tal, etc.), och sedan a.lika med(b) kommer att utvärderas.

Till exempel, anta att nedanstående strängar har samma värden; låt oss testa det med assertEquals:

String obj1 = "Junit";
String obj2 = "Junit";
assertEquals(obj1, obj2);

Ovanstående assert-sats returnerar sant eftersom obj1.equals(obj2) returnerar sant.

Flyttalspåståenden

När du vill jämföra flyttaltyper (t.ex. dubbla or flyta), behöver du en ytterligare obligatorisk parameter, delta-, för att undvika problem med avrundningsfel vid flyttalsjämförelser.

Påståendet utvärderas enligt nedan:

• Math.abs(förväntat – faktiskt) <= delta

Till exempel:

hävdaLika med(aDoubleVärde, ett annatDoubleVärde, 0.001)

JUnit Påstå exempel

Exemplet nedan visar hur man hävdar ett villkor med hjälp av JUnit hävda metoder.

Låt oss skapa en enkel testklass med namnet Junit4AssertionTest.java och en testlöparklass TestRunner.java.

Du kommer att skapa några variabler och viktiga assert-satser i JUnit.

I det här exemplet kommer du att köra vår testklass med hjälp av TestRunner.java.

Steg 1) Låt oss skapa en klass som täcker alla viktiga metoder för assert-satsen i JUnit:

Junit4AssertionTest.java

package guru99.junit;

import static org.junit.Assert.*;
import org.junit.Test;

public class Junit4AssertionTest {

    @Test
    public void testAssert() {

        // Variable declaration
        String string1 = "Junit";
        String string2 = "Junit";
        String string3 = "test";
        String string4 = "test";
        String string5 = null;
        int variable1 = 1;
        int variable2 = 2;
        int[] airethematicArrary1 = { 1, 2, 3 };
        int[] airethematicArrary2 = { 1, 2, 3 };

        // Assert statements
        assertEquals(string1, string2);
        assertSame(string3, string4);
        assertNotSame(string1, string3);
        assertNotNull(string1);
        assertNull(string5);
        assertTrue(variable1 < variable2);
        assertArrayEquals(airethematicArrary1, airethematicArrary2);
    }
}

Steg 2) Du behöver skapa en testrunner-klass för att köra ovanstående klass:

TestRunner.java

package guru99.junit;

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
    public static void main(String[] args) {
        Result result = JUnitCore.runClasses(Junit4AssertionTest.class);
        for (Failure failure : result.getFailures()) {
            System.out.println(failure.toString());
        }
        System.out.println("Result==" + result.wasSuccessful());
    }
}

Steg 3) Låt oss analysera den förväntade utdata steg för steg. Betrakta alla assert-satser en efter en:

1. assertEquals(sträng1, sträng2);

Jämför nu string1="Junit" med string2="Junit" med equals-metoden i Object-klassen. Ersätt assertEquals-metoden med java.lang.Object.equals()-metoden:

sträng1.equals(sträng2) => returnerar sant

Så assertEquals(sträng1, sträng2) kommer att returnera sann.

2. assertSame(sträng3, sträng4);

Funktionen ”assertSame()” är till för att kontrollera att de två objekten refererar till samma objekt. Eftersom string3="test" och string4="test" är både string3 och string4 av samma typ, så assertSame(string3, string4) kommer att returnera sann.

3. assertNotSame(sträng1, sträng3);

Funktionen ”assertNotSame()” är till för att kontrollera att de två objekten inte refererar till samma objekt. Eftersom string1=”Junit” och string3=”test” är både string1 och string3 av olika typer, så assertNotSame(string1, string3) kommer att returnera sann.

4. assertNotNull(sträng1);

Funktionen ”assertNotNull()” är till för att kontrollera att ett objekt inte är null. Eftersom string1=”Junit”, vilket är ett värde som inte är null, kommer assertNotNull(string1) att returnera sann.

5. assertNull(sträng5);

Funktionen "assertNull()" är till för att kontrollera att ett objekt är null. Eftersom string5=null, vilket är ett nullvärde, kommer assertNull(string5) att returnera sann.

6. påståSant(variabel1 < variabel2);

Funktionen ”assertTrue()” är till för att kontrollera att ett villkor är sant. Eftersom variabel1=1 och variabel2=2, vilket visar att variabel1 < variabel2-villkoret är sant, kommer assertTrue(variabel1 < variabel2) att returnera sann.

7. assertArrayEquals(airethematicArrary1, airethematicArrary2);

Funktionen "assertArrayEquals()" är till för att kontrollera att den förväntade arrayen och den resulterande arrayen är lika. Arraytypen kan vara int, long, short, char, byte eller java.lang.Object. Eftersom airethematicArrary1 = { 1, 2, 3 } och airethematicArrary2 = { 1, 2, 3 }, vilket visar att båda arrayerna är lika, kommer assertArrayEquals(airethematicArrary1, airethematicArrary2) att returnera sann.

Eftersom alla sju hävdar uttalanden om Junit4AssertionTest.java class return true, när du kör assert-klassen test returnerar den ett lyckat test (se utdata nedan).

Steg 4) Högerklicka på Junit4AssertionTest.java och klicka på Kör som -> JUnit. Du kommer att se utdata enligt nedan:

Ovanstående resultat visar ett förväntat lyckat testresultat.

Vanliga frågor