Beweringen in JUnit 4 en JUnit 5

1. Inleiding

In dit artikel gaan we de beweringen die beschikbaar zijn in JUnit in detail onderzoeken.

Na de migratie van JUnit 4 naar JUnit 5 en A Guide to JUnit 5-artikelen, gaan we nu in op details over de verschillende beweringen die beschikbaar zijn in JUnit 4 en JUnit 5.

We zullen ook de verbeteringen benadrukken die zijn aangebracht in de beweringen met JUnit 5.

2. Beweringen

Beweringen zijn gebruiksmethoden om bewering van voorwaarden in tests te ondersteunen; deze methoden zijn toegankelijk via het Beweren class, in JUnit 4, en de Beweringen één, in JUnit 5.

Om de leesbaarheid van de test en van de beweringen zelf te vergroten, is het altijd aan te raden om importeren statisch de respectieve klasse. Op deze manier kunnen we rechtstreeks naar de assertion-methode zelf verwijzen zonder de representatieve klasse als voorvoegsel.

Laten we beginnen met het onderzoeken van de beweringen die beschikbaar zijn met JUnit 4.

3. Beweringen in JUnit 4

In deze versie van de bibliotheek zijn beweringen beschikbaar voor alle primitieve typen, Voorwerpen, en arrays (een van de primitieven of Voorwerpen).

De parametervolgorde, binnen de bewering, is de verwachte waarde gevolgd door de werkelijke waarde; optioneel kan de eerste parameter een zijn Draad bericht dat de berichtuitvoer van de geëvalueerde voorwaarde vertegenwoordigt.

Er is slechts één iets anders in hoe de beweren dat beweringen, maar we zullen het later behandelen.

Laten we beginnen met de assertEquals een.

3.1. assertEquals

De assertEquals bewering verifieert dat de verwachte en de werkelijke waarden gelijk zijn:

@Test openbare leegte whenAssertingEquality_thenEqual () {String verwacht = "Baeldung"; String actual = "Baeldung"; assertEquals (verwacht, actueel); }

Het is ook mogelijk om een ​​bericht op te geven dat moet worden weergegeven wanneer de bewering mislukt:

assertEquals ("mislukking - strings zijn niet gelijk", verwacht, actueel);

3.2. assertArrayEquals

Als we willen beweren dat twee arrays gelijk zijn, kunnen we de assertArrayEquals:

@Test openbare leegte whenAssertingArraysEquality_thenEqual () {char [] verwacht = {'J', 'u', 'n', 'i', 't'}; char [] actual = "Junit" .toCharArray (); assertArrayEquals (verwacht, actueel); }

Als beide arrays nul, zal de bewering ze als gelijk beschouwen:

@Test openbare leegte gegevenNullArrays_whenAssertingArraysEquality_thenEqual () {int [] verwacht = null; int [] actueel = null; assertArrayEquals (verwacht, actueel); }

3.3. assertNotNull en bewerenNull

Als we willen testen of een object dat wel is nul we kunnen de bewerenNull bewering:

@Test openbare leegte whenAssertingNull_thenTrue () {Object car = null; assertNull ("De auto moet nul zijn", auto); }

Omgekeerd, als we willen beweren dat een object niet nul mag zijn, kunnen we de assertNotNull bewering.

3.4. assertNotSame en beweren hetzelfde

Met assertNotSame, is het mogelijk om te controleren of twee variabelen niet naar hetzelfde object verwijzen:

@Test openbare leegte whenAssertingNotSameObject_thenDifferent () {Object cat = new Object (); Object hond = nieuw object (); assertNotSame (kat, hond); }

Anders, als we willen verifiëren dat twee variabelen naar hetzelfde object verwijzen, kunnen we de beweren hetzelfde bewering.

3.5. beweren waar en bewerenFalse

Voor het geval we willen verifiëren dat een bepaalde voorwaarde is waar of false, kunnen we respectievelijk de beweren waar bewering of de bewerenFalse een:

@Test public void whenAssertingConditions_thenVerified () {assertTrue ("5 is groter dan 4", 5> 4); assertFalse ("5 is niet groter dan 6", 5> 6); }

3.6. mislukken

De mislukken bewering mislukt een test met een AssertionFailedError. Het kan worden gebruikt om te verifiëren dat er een daadwerkelijke uitzondering wordt gegenereerd of wanneer we een test willen laten mislukken tijdens de ontwikkeling ervan.

Laten we eens kijken hoe we het in het eerste scenario kunnen gebruiken:

@Test openbare leegte whenCheckingExceptionMessage_thenEqual () {probeer {methodThatShouldThrowException (); fail ("Uitzondering niet gegooid"); } catch (UnsupportedOperationException e) {assertEquals ("Operatie niet ondersteund", e.getMessage ()); }}

3.7. beweren dat

De beweren dat assertion is de enige in JUnit 4 die een omgekeerde volgorde van de parameters heeft in vergelijking met de andere assertions.

In dit geval heeft de bewering een optioneel foutbericht, de werkelijke waarde en een Matcher voorwerp.

Laten we eens kijken hoe we deze bewering kunnen gebruiken om te controleren of een array bepaalde waarden bevat:

@Test openbare leegte testAssertThatHasItems () {assertThat (Arrays.asList ("Java", "Kotlin", "Scala"), hasItems ("Java", "Kotlin")); } 

Aanvullende informatie over het krachtige gebruik van de beweren dat bewering met Matcher object, is verkrijgbaar bij Testing with Hamcrest.

4. JUnit 5 beweringen

JUnit 5 heeft veel van de beweringsmethoden van JUnit 4 behouden, terwijl er enkele nieuwe zijn toegevoegd die profiteren van de ondersteuning van Java 8.

Ook in deze versie van de bibliotheek zijn beweringen beschikbaar voor alle primitieve typen, Voorwerpen, en arrays (ofwel primitieven of objecten).

De volgorde van de parameters van de beweringen is gewijzigd, waarbij de parameter voor het uitvoerbericht als de laatste parameter is verplaatst. Dankzij de ondersteuning van Java 8 kan het uitvoerbericht een Leverancier, waardoor een luie evaluatie ervan mogelijk is.

Laten we beginnen met het bekijken van de beweringen die ook beschikbaar zijn in JUnit 4.

4.1. assertArrayEquals

De assertArrayEquals bewering verifieert dat de verwachte en de werkelijke arrays gelijk zijn aan:

@Test openbare leegte whenAssertingArraysEquality_thenEqual () {char [] verwacht = {'J', 'u', 'p', 'i', 't', 'e', ​​'r'}; char [] actual = "Jupiter" .toCharArray (); assertArrayEquals (verwacht, actueel, "Arrays moeten gelijk zijn"); }

Als de arrays niet gelijk zijn, wordt het bericht 'Arrays moeten gelijk zijn”Wordt weergegeven als output.

4.2. assertEquals

Voor het geval we dat twee willen beweren drijft zijn gelijken, we kunnen de simple gebruiken assertEquals bewering:

@Test openbare leegte whenAssertingEquality_thenEqual () {float square = 2 * 2; zwevende rechthoek = 2 * 2; assertEquals (vierkant, rechthoek); }

Als we echter willen beweren dat de werkelijke waarde een vooraf gedefinieerde delta verschilt van de verwachte waarde, kunnen we nog steeds de assertEquals maar we moeten de deltawaarde doorgeven als de derde parameter:

@Test openbare leegte whenAssertingEqualityWithDelta_thenEqual () {float square = 2 * 2; zwevende rechthoek = 3 * 2; zwevende delta = 2; assertEquals (vierkant, rechthoek, delta); }

4.3. beweren waar en bewerenFalse

Met de beweren waar bewering, is het mogelijk om te controleren of de geleverde voorwaarden zijn waar:

@Test public void whenAssertingConditions_thenVerified () {assertTrue (5> 4, "5 is groter dan de 4"); assertTrue (null == null, "null is gelijk aan null"); }

Dankzij de ondersteuning van de lambda-expressie is het mogelijk om een BooleanSupplier aan de bewering in plaats van een boolean staat.

Laten we eens kijken hoe we de juistheid van een BooleanSupplier de ... gebruiken bewerenFalse bewering:

@Test openbare ongeldige gegevenBooleanSupplier_whenAssertingCondition_thenVerified () {BooleanSupplier voorwaarde = () -> 5> 6; assertFalse (voorwaarde, "5 is niet groter dan 6"); }

4.4. bewerenNull en assertNotNull

Als we willen beweren dat een object dat niet is nul we kunnen de assertNotNull bewering:

@Test openbare leegte whenAssertingNotNull_thenTrue () {Object dog = new Object (); assertNotNull (dog, () -> "De hond mag niet null zijn"); }

Omgekeerd kunnen we de bewerenNull bewering om te controleren of de werkelijke is nul:

@ Test openbare leegte whenAssertingNull_thenTrue () {Object cat = null; assertNull (cat, () -> "De kat moet null zijn"); }

In beide gevallen wordt het foutbericht op een luie manier opgehaald omdat het een Leverancier.

4.5. beweren hetzelfde en assertNotSame

Als we willen beweren dat het verwachte en het werkelijke naar hetzelfde verwijzen Voorwerp, we moeten de beweren hetzelfde bewering:

@Test openbare leegte whenAssertingSameObject_thenSuccessfull () {String language = "Java"; Optioneel optioneel = Optioneel.of (taal); assertSame (taal, optioneel.get ()); }

Omgekeerd kunnen we de assertNotSame een.

4.6. mislukken

De mislukken assertion slaagt niet voor een test met het verstrekte foutbericht en de onderliggende oorzaak. Dit kan handig zijn om een ​​test te markeren wanneer deze nog niet is ontwikkeld:

@Test public void whenFailingATest_thenFailed () {// Test niet voltooid, mislukt ("FAIL - test niet voltooid"); }

4.7. assertAll

Een van de nieuwe beweringen die in JUnit 5 zijn geïntroduceerd, is assertAll.

Met deze bewering kunnen gegroepeerde beweringen worden gemaakt, waarbij alle beweringen worden uitgevoerd en hun mislukkingen samen worden gerapporteerd. In detail accepteert deze bewering een kop, die zal worden opgenomen in de berichtstring voor de MultipleFailureError, en een Stroom van Uitvoerbaar.

Laten we een gegroepeerde bewering definiëren:

@Test openbare leegte gegevenMultipleAssertion_whenAssertingAll_thenOK () {assertAll ("heading", () -> assertEquals (4, 2 * 2, "4 is 2 keer 2"), () -> assertEquals ("java", "JAVA" .toLowerCase ()), () -> assertEquals (null, null, "null is gelijk aan null")); }

De uitvoering van een gegroepeerde bewering wordt alleen onderbroken wanneer een van de uitvoerbare bestanden een uitzondering op de zwarte lijst genereert (Onvoldoende geheugen fout bijvoorbeeld).

4.8. assertIterableEquals

De assertIterableEquals beweert dat de verwachte en de feitelijke iterables grotendeels gelijk zijn.

Om gelijk te zijn, moeten beide iterabele gelijke elementen in dezelfde volgorde retourneren en is het niet vereist dat de twee iterabelen van hetzelfde type zijn om gelijk te zijn.

Laten we met deze overweging eens kijken hoe we kunnen beweren dat twee lijsten van verschillende typen (LinkedList en ArrayList bijvoorbeeld) zijn gelijk:

@Test openbare ongeldig gegevenTwoLists_whenAssertingIterables_thenEquals () {Iterable al = nieuwe ArrayList (asList ("Java", "Junit", "Test")); Iterable ll = nieuwe LinkedList (asList ("Java", "Junit", "Test")); assertIterableEquals (al, ll); }

Op dezelfde manier als de assertArrayEquals, als beide iterabelen nul zijn, worden ze als gelijk beschouwd.

4.9. assertLinesMatch

De assertLinesMatch beweert dat de verwachte lijst van Draad komt overeen met de werkelijke lijst.

Deze methode verschilt van de assertEquals en assertIterableEquals aangezien het voor elk paar verwachte en werkelijke lijnen dit algoritme uitvoert:

  1. controleer of de verwachte regel gelijk is aan de werkelijke regel. Zo ja, dan gaat het verder met het volgende paar
  2. behandel de verwachte regel als een reguliere expressie en voer een controle uit met de Draad.wedstrijden() methode. Zo ja, dan gaat het verder met het volgende paar
  3. controleer of de verwachte lijn een snel vooruitspoelen-markering is. Zo ja, pas snel vooruitspoelen toe en herhaal het algoritme vanaf stap 1

Laten we eens kijken hoe we deze bewering kunnen gebruiken om te beweren dat twee lijsten van Draad hebben bijpassende lijnen:

@Test public void whenAssertingEqualityListOfStrings_thenEqual () {List verwacht = asList ("Java", "\ d +", "JUnit"); List actual = asList ("Java", "11", "JUnit"); assertLinesMatch (verwacht, actueel); }

4.10. assertNotEquals

Complementair aan de assertEquals, de assertNotEquals bewering beweert dat de verwachte en de werkelijke waarden niet gelijk zijn:

@Test openbare leegte whenAssertingEquality_thenNotEqual () {Integer waarde = 5; // resultaat van een algoritme assertNotEquals (0, waarde, "Het resultaat mag geen 0 zijn"); }

Als beide dat zijn nul, faalt de bewering.

4.11. assertThrows

Om de eenvoud en leesbaarheid te vergroten, is het nieuwe assertThrows assertion stelt ons een duidelijke en eenvoudige manier in staat om te bevestigen of een uitvoerbaar bestand het gespecificeerde uitzonderingstype genereert.

Laten we eens kijken hoe we een gegooide uitzondering kunnen claimen:

@Test void whenAssertingException_thenThrown () {Throwable exception = assertThrows (IllegalArgumentException.class, () -> {throw new IllegalArgumentException ("Uitzonderingsbericht");}); assertEquals ("Uitzonderingsbericht", exception.getMessage ()); }

De bewering zal mislukken als er geen uitzondering wordt gegenereerd of als een uitzondering van een ander type wordt gegenereerd.

4.12. assertTimeout en assertTimeoutPreemptively

Voor het geval we willen beweren dat de uitvoering van een aangeleverde Uitvoerbaar eindigt vóór een gegeven Time-out, kunnen we de assertTimeout bewering:

@Test public void whenAssertingTimeout_thenNotExceeded () {assertTimeout (ofSeconds (2), () -> {// code die minder dan 2 minuten nodig heeft om Thread.sleep (1000);}) uit te voeren; }

Met de assertTimeout bewering, wordt het geleverde uitvoerbare bestand uitgevoerd in dezelfde thread als de aanroepende code. Bijgevolg wordt de uitvoering van de leverancier niet preventief afgebroken als de time-out wordt overschreden.

Als we zeker willen zijn dat de uitvoering van het uitvoerbare bestand wordt afgebroken zodra deze de time-out overschrijdt, kunnen we de assertTimeoutPreemptively bewering.

Beide beweringen kunnen accepteren, in plaats van een Uitvoerbaar, een ThrowingSupplier, dat een generiek codeblok vertegenwoordigt dat een object retourneert en dat mogelijk een Gooibaar.

5. Conclusie

In deze tutorial hebben we alle beweringen behandeld die beschikbaar zijn in zowel JUnit 4 als JUnit 5.

We hebben kort de verbeteringen belicht die in JUnit 5 zijn aangebracht, met de introductie van nieuwe beweringen en de ondersteuning van lambda's.

Zoals altijd is de volledige broncode voor dit artikel beschikbaar op GitHub.