Het verschil tussen mislukking en fout in JUnit

1. Inleiding

In deze zelfstudie onderzoeken we de verschillen tussen een fout en een fout in JUnit-tests.

Kortom, fouten zijn onvervulde beweringen, terwijl fouten het gevolg zijn van abnormale testuitvoering.

2. Voorbeeldcode

Laten we een heel simplistisch voorbeeld bekijken, namelijk een rekenmachineklasse die één methode heeft om twee te delen dubbele waarden:

openbare statische dubbele divideNumbers (dubbel deeltal, dubbele deler) {if (deler == 0) {gooi nieuwe ArithmeticException ("Delen door nul!"); } dividend / deler teruggeven; }

Let daar op Java gooit eigenlijk geen ArithmeticException op zichzelf voor dubbele divisie - het keert terug Oneindigheid of NaN.

3. Voorbeeld van een mislukking

Bij het schrijven van unit-tests met JUnit, zullen er waarschijnlijk situaties zijn waarin tests mislukken. Een mogelijkheid is dat onze code voldoet niet aan de testcriteria. Dat betekent dat een of meer testcases mislukken vanwege beweringen worden niet vervuld.

In het volgende voorbeeld zal de bewering mislukken, omdat het resultaat van de deling 2 is en niet 15. Onze bewering en het werkelijke resultaat komen eenvoudigweg niet overeen:

@Test ongeldig whenDivideNumbers_thenExpectWrongResult () {dubbel resultaat = SimpleCalculator.divideNumbers (6, 3); assertEquals (15, resultaat); }

4. Voorbeeldfout

Een andere mogelijkheid is dat we hebben een onverwachte situatie tijdens het uitvoeren van de test, waarschijnlijk als gevolg van een uitzondering; bijvoorbeeld toegang tot een nul referentie zal een RuntimeException.

Laten we een voorbeeld bekijken, waarbij de test wordt afgebroken met een fout omdat we proberen te delen door nul, waartegen we expliciet waken door een uitzondering in onze rekenmachinecode te gooien:

@Test ongeldig whenDivideByZero_thenThrowsException () {SimpleCalculator.divideNumbers (10, 0); } 

Nu kunnen we deze test oplossen door simpelweg de uitzondering op te nemen als een van onze beweringen.

@Test ongeldig whenDivideByZero_thenAssertException () {assertThrows (ArithmeticException.class, () -> SimpleCalculator.divideNumbers (10, 0)); }

Als de uitzondering wordt gegenereerd, slaagt de test, maar zo niet, dan zou dat weer een mislukking zijn.

5. Conclusie

Zowel falen als fouten in JUnit-tests duiden op een ongewenste situatie, maar hun semantiek is anders. Storingen wijzen op een ongeldig testresultaat, fouten duiden op een onverwachte testuitvoering.

Bekijk ook de voorbeeldcode op GitHub.