Utforska Java Unit Testing med JUnit Test Framework

JUnit är ett ramverk för testning av enheter med öppen källkod från tredje part. Projektet startades av Kent Beck och Erich Gamma i slutet av 1995. Det väckte snabbt intresse i samhället av utvecklare som särskilt sysslar med testdriven utveckling. JUnit introducerades från början till Smalltalk, men portades senare till Java, som snabbt tog upp detta som en de-facto standard för enhetstestning. Populariteten för JUnit växte till en sådan grad att, för att tillgodose behoven hos många andra samtida språk som C#, Perl, Python, PHP, Ruby, Visual Basic, C++ och så vidare, utvecklades ett generiskt xUnit-ramverk där bokstaven 'x' ersätts av den första bokstaven i språket, som JUnit för Java, RUnit för Ruby, och så vidare. Den här artikeln ger en översikt över detta ramverk som används av de-facto-standarden för Java-enhetstestning.

Testöversikt

Testning är en viktig fas i livscykeln för en applikationsutveckling. Huvudsyftet med testning är att utvärdera ett program utifrån erforderliga specifikationer. Målet är att skapa vissa testfall som upptäcker fel, luckor, eventuella avvikelser eller oväntade utfall, så mycket som möjligt. Detta enkla koncept har några utarbetade processer förknippade med det. Men för att uttrycka det kortfattat, det görs på tre nivåer. När testningen görs på mycket granulär eller individuell komponentnivå kallas det Enhetstestning; när de kombineras för att kontrollera gränssnitten mellan komponenter mot en mjukvarudesign kallas det Integrationstestning; och slutligen, när hela systemet är integrerat och testning görs för att verifiera att systemet som helhet uppfyller det angivna kravet, kallas det Systemtestning .

Enhetstestning

I ett nötskal, att utföra ett enhetstest är ett sätt att undersöka beteendet hos en distinkt kodenhet. I Java, en kodenhet kan betyda en metod eller en klass eller till och med en modul, beroende på sammanhanget. Om det är en metod, till exempel, är fokus för testet på att utvärdera rätt objektreferens som får anropa metoden, typ av parametrar och acceptabla värden, primitiva värdeintervall, returtyp och värde, och så vidare. Tanken är att grilla metoden så att den kan göras robust nog att graciöst hantera sitt problem och kasta de som ligger utanför dess räckvidd förutom att uppfylla sitt kontrakt.

Därför utgör enhetstestning den grundläggande byggstenen i varje programutvärdering. Faktum är att varje programmerare utför någon form av enhetstestning när man skriver kod för att kontrollera resultatet av koden med några dummydata/fall. Enhetstestning är alltså en formell status som ges till den isolerade samlingen av tester. Det är extremt viktigt att en kod går igenom rigoriteten i olika testfaser. Enhetstestningen är, förutom dess betydelse, också mycket vanlig. Människor som Kent Beck och Erich Gamma tänkte skapa ett ramverk för det så att programmerare får en strukturerad miljö och kan automatisera många av dessa uppgifter. Det är trots allt vad ett ramverk är till för. Vanligtvis ger det en sammanhängande programstruktur som är återanvändbar och delas mellan applikationer. En programmerare kan infoga dem i en befintlig applikation och utöka dem efter dess specifika behov.

Ett snabbt exempel

En enkel enhetstestkod för att undersöka den enskilda metoden i Temperatur klass utan att använda JUnit-ramverket är som följer:

package org.mano.unittest.examples;
public class Circle {
   double area(double radius) {
      returnMath.PI* radius * radius;
   }
}

Låt oss nu skriva koden för att enhetstesta området metod.

package org.mano.unittest.examples;

public class CircleTest {
   public int errCounter= 0;
   public void testCircleArea() {
      Circle circle = new Circle();
      double area = circle.area(12);
      if (area < 452 && area > 453) {
         throw new IllegalStateException("Wrong calculation!: "
            + area);
      }
   }

   public static void main(String[] args) {
      TestCircle test = new TestCircle();
      try {
         test.testCircleArea();
      } catch (Throwable e) {
         test.errCounter++;
         e.printStackTrace();
      }
      if (test.errCounter> 0) {
         throw new IllegalStateException("There were "
            + test.errCounter+ " error(s)");
      }
   }
}

Detta är ett rudimentärt exempel, men ger dig en uppfattning om hur enhetstestning kan göras utan att använda något ramverk.

JUnit Testing Framework

Att använda JUnit-ramverket för enhetstestning har flera fördelar. Den tillhandahåller många kommentarer som gör det enkelt att skriva och köra testkoder i Java:

I första hand skiljer det problemet med enhetstestning från den faktiska projektkoden genom att göra det möjligt för en att skapa en testklassinstans och klassladdare för varje enhetstest. Dessa "immunerar" den befintliga koden från onödiga biverkningar av testning.
Annoteringarna som tillhandahålls av JUnit – som @Before, @After, @BeforeClass, @AfterClass —ha metoder för både resursinitiering och resursåtervinning.
Det finns en mängd olika påståendemetoder för att verifiera resultatet av ett test.
Under åren blev JUnit så populärt att många Java-verktyg, som Ant och Maven; och populära IDE, som Eclipse , NetBeans , IntelliJ IDÉ , och liknande, kommer med inbyggd integration av JUnit.

För att använda JUnit Test Framework i ett Java-projekt måste man lägga till en JUnit JAR-fil i projektklassens sökväg. Detta krävs uttryckligen om IDE:n inte är integrerad med JUnit-biblioteket. Processen är enkel. Ladda ner JAR-filen och lägg till den i projektklassens sökväg.

Här är några viktiga länkar till JUnit-ramverket.

JUnits officiella webbplats
JUnit Java API
JUnit användarhandbok
JUnit-källkod i GitHub

Till skillnad från JUnit 4 och dess föregångare medförde JUnit 5 några betydande förändringar. Bortsett från många nya funktioner som lagts till&mdahs;som lambda-stöd, nya anteckningar och testmetodparameterinjektion - har kärnarkitekturen fått en betydande modifiering. JUnit 5 är nu en sammansatt arkitektur av tre olika moduler:JUnit Jupiter, JUnit Vintage och JUnit Platform. Testfallsutvecklarna behöver dock inte bry sig om förändringarnas krångligheter. Förändringarna innebär i första hand bättre verktygsstöd, konsekvens och renare API:er. Framför allt är den direkt bakåtkompatibel med JUnit 4. Så, inga bekymmer där heller. Se användarhandboken för JUnit 5 för mer information.

Ett snabbt exempel

Här är ett mycket enkelt exempel för att få en inblick i hur enhetstestning kan göras med JUnit-ramverket. Vi använder Anställd klass för enhetstestet och skapa en testklass för att ge en uppfattning om hur den fungerar. Exemplet är rudimentärt när det gäller att skriva ett "Hello World"-program. Verkliga testfall, eller till och med ett anständigt exempel på enhetstest, kräver en bra mängd kod. Vi kanske provar det i någon annan artikel.

package org.mano.unittest.examples;
public class Employee {
   private final String name;
   private final double basicPay;
   public Employee(String name, double basicPay) {
      this.name=name;
      this.basicPay=basicPay;
   }
   public String getName() {
      return name;
   }
   public double getBasicPay() {
      return basicPay;
   }
}

package org.mano.unittest.examples;
import org.junit.Test;
import static org.junit.Assert.*;
public class EmployeeTest {
   @Test
   public void constructorInitTest(){
      Employee emp=new Employee("Odin", 2300);
      assertEquals("Odin", emp.getName());
      assertEquals(2300, emp.getBasicPay(), 0.001);
   }
}

package org.mano.unittest.examples;
public class EmployeeTestMain {
   public static void main(String[] args){
      EmployeeTest et=new EmployeeTest();
      et.constructorInitTest();
   }
}

Observera att klassen Employee är oföränderlig med endast två fält inställda av konstruktorn. Eftersom endast konstruktörsmetoden är värd att testa, testar vi bara den.

Testklassen heter EmployeeTest enligt konventionen. Anteckningen @Test gör det möjligt för JUnit att utse en metod som en testmetod. Det finns en mängd olika påståmetoder i Assert klass. Här har vi bara använt assertEquals .

Det finns många sätt att köra ett test skrivet i JUnit. Vanligtvis, efter att testfallen har körts, skrivs en sammanfattning ut. Det kan dock variera beroende på hur testet körs. Det kan köras genom IDE som Eclipse eller IntelliJ, eller verktyg som Maven, Gradle och så vidare. Ibland är den enda information som tas emot efter testet att det antingen har underkänts eller godkänts.

Slutsats

Det finns flera andra ramverk för enhetstestning. JUnit är ett populärt ramverk för enhetstestning bland Java-gemenskapen. Testning som en systemteknisk fas har mycket mer process inblandad. Enhetstestning är bara en del av det och intressant nog kan många speltest som görs av utvecklaren betecknas som enhetstestning. JUnit, som ett testramverk, tillför värde till det. Annoteringarna och API:erna som tillhandahålls av JUnit automatiserar många uppgifter och gör livet mycket lättare för utvecklarna av enhetstest.