JUnit - Szybki przewodnik

Testowanie to proces sprawdzania funkcjonalności aplikacji w celu upewnienia się, że działa ona zgodnie z wymaganiami. Testowanie jednostkowe pojawia się na poziomie deweloperów; jest to testowanie pojedynczej jednostki (klasy lub metody). Testy jednostkowe odgrywają kluczową rolę, pomagając firmie programistycznej dostarczać klientom produkty wysokiej jakości.

Testowanie jednostkowe można przeprowadzić na dwa sposoby - testowanie ręczne i testowanie automatyczne.

Testowanie ręczne	Testowanie automatyczne
Ręczne wykonywanie przypadków testowych bez wsparcia narzędzi jest nazywane testowaniem ręcznym.	Korzystanie ze wsparcia narzędziowego i wykonywanie przypadków testowych za pomocą narzędzia do automatyzacji jest znane jako testowanie automatyzacji.
Time-consuming and tedious - Ponieważ przypadki testowe są wykonywane przez zasoby ludzkie, jest to bardzo powolne i żmudne.	Fast - Automatyzacja uruchamia przypadki testowe znacznie szybciej niż zasoby ludzkie.
Huge investment in human resources - Ponieważ przypadki testowe muszą być wykonywane ręcznie, do testowania ręcznego potrzeba więcej testerów.	Less investment in human resources - Przypadki testowe są wykonywane przy użyciu narzędzi do automatyzacji, więc w testowaniu automatyzacji wymagana jest mniejsza liczba testerów.
Less reliable - Testowanie ręczne jest mniej niezawodne, ponieważ musi uwzględniać błędy ludzkie.	More reliable - Testy automatyczne są precyzyjne i wiarygodne.
Non-programmable - Nie można programować, aby napisać zaawansowane testy w celu pobrania ukrytych informacji.	Programmable - Testerzy mogą programować zaawansowane testy, aby wydobyć ukryte informacje.

Co to jest JUnit?

JUnit to platforma do testów jednostkowych dla języka programowania Java. Odgrywa kluczową rolę w programowaniu opartym na testach i jest rodziną frameworków do testowania jednostkowego zwanych łącznie xUnit.

JUnit promuje ideę „najpierw testowania, a następnie kodowania”, która kładzie nacisk na konfigurowanie danych testowych dla fragmentu kodu, który można najpierw przetestować, a następnie zaimplementować. To podejście przypomina „trochę przetestuj, trochę zakoduj, trochę przetestuj, trochę zakoduj”. Zwiększa produktywność programisty i stabilność kodu programu, co z kolei zmniejsza stres programisty i czas poświęcany na debugowanie.

Funkcje JUnit

JUnit to framework open source, który służy do pisania i uruchamiania testów.
Zawiera adnotacje umożliwiające identyfikację metod testowych.
Zapewnia potwierdzenia do testowania oczekiwanych wyników.
Udostępnia programy uruchamiające testy do przeprowadzania testów.
Testy JUnit pozwalają na szybsze pisanie kodów, co podnosi jakość.
JUnit jest elegancko prosty. Jest mniej skomplikowany i zajmuje mniej czasu.
Testy JUnit mogą być uruchamiane automatycznie i sprawdzają własne wyniki i zapewniają natychmiastową informację zwrotną. Nie ma potrzeby ręcznego przeczesywania raportu wyników testu.
Testy JUnit można organizować w zestawy testów zawierające przypadki testowe, a nawet inne zestawy testów.
JUnit pokazuje postęp testu na pasku, który jest zielony, jeśli test przebiega płynnie, a zmienia kolor na czerwony, gdy test się nie powiedzie.

Co to jest przypadek testu jednostkowego?

Przypadek testu jednostkowego to część kodu, która zapewnia, że inna część kodu (metoda) działa zgodnie z oczekiwaniami. Aby szybko osiągnąć pożądane wyniki, wymagana jest platforma testowa. JUnit to doskonała platforma do testów jednostkowych dla języka programowania Java.

Formalny pisemny przypadek testu jednostkowego charakteryzuje się znanymi danymi wejściowymi i oczekiwanymi danymi wyjściowymi, które są opracowywane przed wykonaniem testu. Znane dane wejściowe powinny testować warunek wstępny, a oczekiwane dane wyjściowe powinny testować warunek końcowy.

Dla każdego wymagania muszą istnieć co najmniej dwa przypadki testów jednostkowych - jeden test pozytywny i jeden test negatywny. Jeśli wymaganie zawiera wymagania podrzędne, każde wymaganie podrzędne musi mieć co najmniej dwa przypadki testowe jako pozytywne i negatywne.

Konfiguracja środowiska lokalnego

JUnit to framework dla Javy, więc pierwszym wymaganiem jest zainstalowanie JDK na twoim komputerze.

Wymagania systemowe

JDK	1.5 lub nowszy.
Pamięć	Brak minimalnych wymagań.
Miejsca na dysku	Brak minimalnych wymagań.
System operacyjny	Brak minimalnych wymagań.

Krok 1: Zweryfikuj instalację Java na swoim komputerze

Przede wszystkim otwórz konsolę i wykonaj polecenie java w oparciu o system operacyjny, na którym pracujesz.

OS	Zadanie	Komenda
Windows	Otwórz konsolę poleceń	c: \> java -version
Linux	Otwórz terminal poleceń	$ java -version
Prochowiec	Otwórz terminal	maszyna: ~ joseph $ java -version

Sprawdźmy dane wyjściowe dla wszystkich systemów operacyjnych -

OS	Wynik
Windows	wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101)
Linux	wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101)
Prochowiec	wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101)

Jeśli nie masz zainstalowanej Java w swoim systemie, pobierz pakiet Java Software Development Kit (SDK) z poniższego łącza https://www.oracle.com. Zakładamy Java 1.8.0_101 jako zainstalowaną wersję tego samouczka.

Krok 2: Ustaw środowisko JAVA

Ustaw JAVA_HOMEzmienna środowiskowa wskazująca lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład.

OS	Wynik
Windows	Ustaw zmienną środowiskową JAVA_HOME na C: \ Program Files \ Java \ jdk1.8.0_101
Linux	eksportuj JAVA_HOME = / usr / local / java-current
Prochowiec	eksportuj JAVA_HOME = / Library / Java / Home

Dołącz lokalizację kompilatora Java do ścieżki systemowej.

OS	Wynik
Windows	Dołącz ciąg C:\Program Files\Java\jdk1.8.0_101\bin na końcu zmiennej systemowej, Path.
Linux	eksportuj PATH = $PATH:$JAVA_HOME / bin /
Prochowiec	nie wymagane

Sprawdź instalację oprogramowania Java za pomocą polecenia java -version jak wyjaśniono powyżej.

Krok 3: Pobierz archiwum JUnit

Pobierz najnowszą wersję pliku jar JUnit z witryny http://www.junit.org. W czasie pisania tego samouczka pobraliśmy Junit-4.12.jar i skopiowaliśmy go do folderu C: \> JUnit.

OS	Nazwa archiwum
Windows	junit4.12.jar
Linux	junit4.12.jar
Prochowiec	junit4.12.jar

Krok 4: Ustaw środowisko JUnit

Ustaw JUNIT_HOMEzmienna środowiskowa, aby wskazać lokalizację katalogu podstawowego, w którym na komputerze jest przechowywany JUNIT jar. Załóżmy, że przechowujemy junit4.12.jar w folderze JUNIT.

Sr.No	System operacyjny i opis
1	Windows Ustaw zmienną środowiskową JUNIT_HOME na C: \ JUNIT
2	Linux export JUNIT_HOME = / usr / local / JUNIT
3	Mac eksportuj JUNIT_HOME = / Library / JUNIT

Krok 5: Ustaw zmienną CLASSPATH

Ustaw CLASSPATH zmienna środowiskowa wskazująca lokalizację jar JUNIT.

Sr.No	System operacyjny i opis
1	Windows Ustaw zmienną środowiskową CLASSPATH na% CLASSPATH%;% JUNIT_HOME% \ junit4.12.jar;.;
2	Linux eksportuj CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.
3	Mac eksportuj CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.

Krok 6: Przetestuj JUnit Setup

Utwórz nazwę pliku klasy Java TestJunit in C:\>JUNIT_WORKSPACE

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

public class TestJunit {
   @Test
	
   public void testAdd() {
      String str = "Junit is working fine";
      assertEquals("Junit is working fine",str);
   }
}

Utwórz nazwę pliku klasy Java TestRunner w programie C:\>JUNIT_WORKSPACE do wykonania przypadków testowych.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Krok 7: Sprawdź wynik

Skompiluj klasy przy użyciu javac kompilator w następujący sposób -

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

Teraz uruchom Test Runner, aby zobaczyć wynik w następujący sposób -

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

true

JUnit to Regression Testing Frameworkużywany przez programistów do implementacji testów jednostkowych w Javie i przyspieszenia programowania oraz podniesienia jakości kodu. JUnit Framework można łatwo zintegrować z jednym z następujących:

Eclipse
Ant
Maven

Funkcje JUnit Test Framework

Framework testowy JUnit zapewnia następujące ważne funkcje -

Fixtures
Zestawy testowe
Biegacze testowi
Klasy JUnit

Oprawy

Fixturesjest ustalonym stanem zbioru obiektów używanym jako podstawa do uruchamiania testów. Celem osprzętu testowego jest zapewnienie, że istnieje dobrze znane i ustalone środowisko, w którym przeprowadzane są testy, tak aby wyniki były powtarzalne. Obejmuje -

setUp (), która jest uruchamiana przed każdym wywołaniem testu.
tearDown (), która jest uruchamiana po każdej metodzie testowej.

Sprawdźmy jeden przykład -

import junit.framework.*;

public class JavaTest extends TestCase {
   protected int value1, value2;
   
   // assigning the values
   protected void setUp(){
      value1 = 3;
      value2 = 3;
   }

   // test method to add two values
   public void testAdd(){
      double result = value1 + value2;
      assertTrue(result == 6);
   }
}

Zestawy testowe

Zestaw testów zawiera kilka przypadków testów jednostkowych i uruchamia je razem. W JUnit zarówno adnotacje @RunWith, jak i @Suite są używane do uruchamiania testu pakietu. Poniżej podano przykład wykorzystujący klasy testowe TestJunit1 i TestJunit2.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

//JUnit Suite Test
@RunWith(Suite.class)

@Suite.SuiteClasses({ 
   TestJunit1.class ,TestJunit2.class
})

public class JunitTestSuite {
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Testuj biegaczy

Test runner służy do wykonywania przypadków testowych. Oto przykład, który zakłada klasę testowąTestJunit już istnieje.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Klasy JUnit

Klasy JUnit są ważnymi klasami używanymi do pisania i testowania JUnitów. Niektóre z ważnych klas to:

Assert - Zawiera zestaw metod potwierdzania.
TestCase - Zawiera przypadek testowy, który definiuje urządzenie do uruchamiania wielu testów.
TestResult - Zawiera metody zbierania wyników wykonania przypadku testowego.

Przejdźmy teraz do podstawowego przykładu pokazującego krok po kroku proces korzystania z JUnit.

Utwórz klasę

Utwórz klasę Java do przetestowania, na przykład MessageUtil.java in C:\>JUNIT_WORKSPACE

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
	
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Utwórz klasę przypadku testowego

Utwórz klasę testową Java, na przykład TestJunit.java.
Dodaj metodę testową testPrintMessage () do swojej klasy testowej.
Dodaj Annotaion @Test do metody testPrintMessage ().
Zaimplementuj warunek testowy i sprawdź warunek za pomocą funkcji API assertEquals JUnit.

Utwórz nazwę pliku klasy Java TestJunit.java w formacie C:\>JUNIT_WORKSPACE.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Utwórz testową klasę biegacza

Utwórz klasę Java TestRunner.
Użyj metody runClasses klasy JUnitCore klasy JUnit, aby uruchomić przypadek testowy powyższej klasy testowej.
Uzyskaj wynik przypadków testowych uruchomionych w obiekcie Result.
Uzyskaj niepowodzenie (a) za pomocą metody getFailures () obiektu Result.
Uzyskaj wynik Success przy użyciu metody wasSuccessful () obiektu Result.

Utwórz plik klasy Java o nazwie TestRunner.java w programie C:\>JUNIT_WORKSPACE do wykonania przypadków testowych.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy MessageUtil, Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

Hello World
true

Teraz zaktualizuj TestJunit w C:\>JUNIT_WORKSPACEtak, że test się nie powiedzie. Zmień ciąg wiadomości.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      message = "New Word";
      assertEquals(message,messageUtil.printMessage());
   }
}

Zachowajmy resztę klas bez zmian i spróbujmy uruchomić tego samego testera.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

Najważniejszym pakietem w JUnit jest junit.framework, który zawiera wszystkie podstawowe klasy. Oto niektóre z ważnych klas:

Sr.No.	Nazwa klasy	Funkcjonalność
1	Zapewniać	Zestaw metod asertywnych.
2	TestCase	Przypadek testowy definiuje urządzenie do uruchamiania wielu testów.
3	Wynik testu	TestResult zbiera wyniki wykonania przypadku testowego.
4	TestSuite	TestSuite to zbiór testów.

Klasa Assert

Poniżej znajduje się deklaracja dla org.junit.Assert klasa -

public class Assert extends java.lang.Object

Ta klasa udostępnia zestaw metod potwierdzania przydatnych do pisania testów. Rejestrowane są tylko nieudane potwierdzenia. Oto niektóre z ważnych metod klasy Assert -

Sr.No.	Metody i opis
1	void assertEquals(boolean expected, boolean actual) Sprawdza, czy dwa prymitywy / obiekty są równe.
2	void assertFalse(boolean condition) Sprawdza, czy warunek jest fałszywy.
3	void assertNotNull(Object object) Sprawdza, czy obiekt nie jest pusty.
4	void assertNull(Object object) Sprawdza, czy obiekt ma wartość null.
5	void assertTrue(boolean condition) Sprawdza, czy warunek jest prawdziwy.
6	void fail() Test nie powiedzie się i nie ma wiadomości.

Wykorzystajmy na przykładzie niektóre z wyżej wymienionych metod. Utwórz plik klasy Java o nazwie TestJunit1.java w formacieC:\>JUNIT_WORKSPACE.

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

public class TestJunit1 {
   @Test
   public void testAdd() {
      //test data
      int num = 5;
      String temp = null;
      String str = "Junit is working fine";

      //check for equality
      assertEquals("Junit is working fine", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(temp);
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner1.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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

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

Skompiluj przypadek testowy i klasy Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner1

Sprawdź dane wyjściowe.

true

Klasa TestCase

Poniżej znajduje się deklaracja dla org.junit.TestCase klasa -

public abstract class TestCase extends Assert implements Test

Przypadek testowy definiuje urządzenie do uruchamiania wielu testów. Niektóre z ważnych metodTestCase klasa są następujące -

Sr.No.	Metody i opis
1	int countTestCases() Zlicza liczbę przypadków testowych wykonanych przez uruchomienie (wynik TestResult).
2	TestResult createResult() Tworzy domyślny obiekt TestResult.
3	String getName() Pobiera nazwę TestCase.
4	TestResult run() Wygodna metoda uruchamiania tego testu polegająca na zbieraniu wyników za pomocą domyślnego obiektu TestResult.
5	void run(TestResult result) Uruchamia przypadek testowy i zbiera wyniki w TestResult.
6	void setName(String name) Ustawia nazwę przypadku TestCase.
7	void setUp() Konfiguruje urządzenie, na przykład otwiera połączenie sieciowe.
8	void tearDown() Zrywa urządzenie, na przykład zamyka połączenie sieciowe.
9	String toString() Zwraca ciąg znaków reprezentujący przypadek testowy.

Wykorzystajmy na przykładzie niektóre z wyżej wymienionych metod. Utwórz plik klasy Java o nazwieTestJunit2.java w C: \> JUNIT_WORKSPACE.

import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;

public class TestJunit2 extends TestCase  {
   protected double fValue1;
   protected double fValue2;
   
   @Before 
   public void setUp() {
      fValue1 = 2.0;
      fValue2 = 3.0;
   }
	
   @Test
   public void testAdd() {
      //count the number of test cases
      System.out.println("No of Test Case = "+ this.countTestCases());
		
      //test getName 
      String name = this.getName();
      System.out.println("Test Case Name = "+ name);

      //test setName
      this.setName("testNewAdd");
      String newName = this.getName();
      System.out.println("Updated Test Case Name = "+ newName);
   }
	
   //tearDown used to close the connection or clean up activities
   public void tearDown(  ) {
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner2.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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

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

Skompiluj przypadek testowy i klasy Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner2

Sprawdź dane wyjściowe.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

Klasa TestResult

Poniżej znajduje się deklaracja dla org.junit.TestResult klasa -

public class TestResult extends Object

TestResult zbiera wyniki wykonania przypadku testowego. Jest to instancja wzorca Collecting Parameter. Struktura testów rozróżnia niepowodzenia i błędy. Awaria jest przewidywana i sprawdzana za pomocą asercji. Błędy to nieoczekiwane problemy, takie jak wyjątek ArrayIndexOutOfBoundsException. Niektóre z ważnych metodTestResult klasa są następujące -

Sr.No.	Metody i opis
1	void addError(Test test, Throwable t) Dodaje błąd do listy błędów.
2	void addFailure(Test test, AssertionFailedError t) Dodaje awarię do listy awarii.
3	void endTest(Test test) Informuje wynik, że test został zakończony.
4	int errorCount() Pobiera liczbę wykrytych błędów.
5	Enumeration<TestFailure> errors() Zwraca wyliczenie dla błędów.
6	int failureCount() Pobiera liczbę wykrytych błędów.
7	void run(TestCase test) Uruchamia testCase.
8	int runCount() Pobiera liczbę uruchomionych testów.
9	void startTest(Test test) Informuje wynik, że test zostanie uruchomiony.
10	void stop() Oznaczenia, że uruchomienie próbne powinno się zakończyć.

Utwórz plik klasy Java o nazwie TestJunit3.java w C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;

public class TestJunit3 extends TestResult {
   // add the error
   public synchronized void addError(Test test, Throwable t) {
      super.addError((junit.framework.Test) test, t);
   }

   // add the failure
   public synchronized void addFailure(Test test, AssertionFailedError t) {
      super.addFailure((junit.framework.Test) test, t);
   }
	
   @Test
   public void testAdd() {
      // add any test
   }
   
   // Marks that the test run should stop.
   public synchronized void stop() {
      //stop the test here
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner3.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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

public class TestRunner3 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit3.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj przypadek testowy i klasy Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner3

Sprawdź dane wyjściowe.

true

Klasa TestSuite

Poniżej znajduje się deklaracja dla org.junit.TestSuite klasa:

public class TestSuite extends Object implements Test

TestSuite to zbiór testów. Uruchamia zbiór przypadków testowych. Niektóre z ważnych metodTestSuite klasa są następujące -

Sr.No.	Metody i opis
1	void addTest(Test test) Dodaje test do zestawu.
2	void addTestSuite(Class<? extends TestCase> testClass) Dodaje testy z danej klasy do pakietu.
3	int countTestCases() Zlicza liczbę przypadków testowych, które zostaną uruchomione przez ten test.
4	String getName() Zwraca nazwę zestawu.
5	void run(TestResult result) Uruchamia testy i zbiera ich wynik w TestResult.
6	void setName(String name) Ustawia nazwę pakietu.
7	Test testAt(int index) Zwraca test o podanym indeksie.
8	int testCount() Zwraca liczbę testów w tym zestawie.
9	static Test warning(String message) Zwraca test, który zakończy się niepowodzeniem i zarejestruje komunikat ostrzegawczy.

Utwórz plik klasy Java o nazwie JunitTestSuite.java w C: \> JUNIT_WORKSPACE, aby utworzyć zestaw testów.

import junit.framework.*;

public class JunitTestSuite {
   public static void main(String[] a) {
      // add the test's in the suite
      TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
      TestResult result = new TestResult();
      suite.run(result);
      System.out.println("Number of test cases = " + result.runCount());
   }
}

Skompiluj klasy zestawu testów przy użyciu javac.

C:\JUNIT_WORKSPACE>javac JunitTestSuite.java

Teraz uruchom Test Suite.

C:\JUNIT_WORKSPACE>java JunitTestSuite

Sprawdź dane wyjściowe.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3

Tutaj zobaczymy jeden kompletny przykład testowania JUnit przy użyciu klasy POJO, klasy logiki biznesowej i klasy testowej, które zostaną uruchomione przez moduł uruchamiający testy.

Stwórz EmployeeDetails.java w C: \> JUNIT_WORKSPACE, która jest klasą POJO.

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   /**
   * @return the name
   */
	
   public String getName() {
      return name;
   }
	
   /**
   * @param name the name to set
   */
	
   public void setName(String name) {
      this.name = name;
   }
	
   /**
   * @return the monthlySalary
   */
	
   public double getMonthlySalary() {
      return monthlySalary;
   }
	
   /**
   * @param monthlySalary the monthlySalary to set
   */
	
   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
	
   /**
   * @return the age
   */
   public int getAge() {
      return age;
   }
	
   /**
   * @param age the age to set
   */
   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails klasa jest używana do -

pobierz / ustaw wartość nazwiska pracownika.
uzyskać / ustawić wysokość miesięcznego wynagrodzenia pracownika.
pobrać / ustawić wartość wieku pracownika.

Utwórz plik o nazwie EmpBusinessLogic.java w C: \> JUNIT_WORKSPACE, który zawiera logikę biznesową.

public class EmpBusinessLogic {
   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {
      double appraisal = 0;
		
      if(employeeDetails.getMonthlySalary() < 10000){
         appraisal = 500;
      }else{
         appraisal = 1000;
      }
		
      return appraisal;
   }
}

EmpBusinessLogic klasa służy do obliczania -

roczne wynagrodzenie pracownika.
wycenę pracownika.

Utwórz plik o nazwie TestEmployeeDetails.java w C: \> JUNIT_WORKSPACE, który zawiera przypadki testowe do przetestowania.

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

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   //test to check appraisal
   @Test
   public void testCalculateAppriasal() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      assertEquals(500, appraisal, 0.0);
   }

   // test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      assertEquals(96000, salary, 0.0);
   }
}

TestEmployeeDetails klasa służy do testowania metod EmpBusinessLogicklasa. To

testuje roczne wynagrodzenie pracownika.
sprawdza wycenę pracownika.

Następnie utwórz plik klasy java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(TestEmployeeDetails.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj przypadek testowy i klasy Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

true

Twierdzenie

Wszystkie potwierdzenia znajdują się w klasie Assert.

public class Assert extends java.lang.Object

Ta klasa udostępnia zestaw metod potwierdzania przydatnych przy pisaniu testów. Rejestrowane są tylko nieudane potwierdzenia. Oto niektóre z ważnych metod klasy Assert -

Sr.No.	Metody i opis
1	void assertEquals(boolean expected, boolean actual) Sprawdza, czy dwa prymitywy / obiekty są równe.
2	void assertTrue(boolean condition) Sprawdza, czy warunek jest prawdziwy.
3	void assertFalse(boolean condition) Sprawdza, czy warunek jest fałszywy.
4	void assertNotNull(Object object) Sprawdza, czy obiekt nie jest pusty.
5	void assertNull(Object object) Sprawdza, czy obiekt ma wartość null.
6	void assertSame(object1, object2) Metoda assertSame () sprawdza, czy dwa odwołania do obiektów wskazują na ten sam obiekt.
7	void assertNotSame(object1, object2) Metoda assertNotSame () sprawdza, czy dwa odwołania do obiektów nie wskazują na ten sam obiekt.
8	void assertArrayEquals(expectedArray, resultArray); Metoda assertArrayEquals () sprawdzi, czy dwie tablice są sobie równe.

Wykorzystajmy na przykładzie niektóre z wyżej wymienionych metod. Utwórz plik klasy Java o nazwieTestAssertions.java w C: \> JUNIT_WORKSPACE.

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

public class TestAssertions {

   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
		
      int val1 = 5;
      int val2 = 6;

      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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

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

Skompiluj klasy Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

true

Adnotacja

Adnotacje są jak metatagi, które można dodawać do kodu i stosować do metod lub w klasie. Te adnotacje w JUnit zawierają następujące informacje o metodach testowych -

które metody będą uruchamiane przed i po metodach testowych.
które metody są uruchamiane przed i po wszystkich metodach oraz.
które metody lub klasy zostaną zignorowane podczas wykonywania.

Poniższa tabela zawiera listę adnotacji i ich znaczenie w JUnit -

Sr.No.	Adnotacja i opis
1	@Test Adnotacja Test informuje JUnit, że publiczną metodę void, do której jest dołączona, można uruchomić jako przypadek testowy.
2	@Before Niektóre testy wymagają utworzenia podobnych obiektów, zanim będą mogły zostać uruchomione. Adnotowanie publicznej metody void za pomocą @Before powoduje, że ta metoda jest uruchamiana przed każdą metodą Test.
3	@After Jeśli przydzielasz zasoby zewnętrzne w metodzie Before, musisz zwolnić je po uruchomieniu testu. Adnotacja publicznej metody void za pomocą @After powoduje, że ta metoda jest uruchamiana po metodzie Test.
4	@BeforeClass Dodanie adnotacji do publicznej statycznej metody void za pomocą @BeforeClass powoduje, że jest ona uruchamiana raz przed którąkolwiek z metod testowych w klasie.
5	@AfterClass Spowoduje to wykonanie metody po zakończeniu wszystkich testów. Można to wykorzystać do wykonywania czynności porządkowych.
6	@Ignore Adnotacja Ignoruj służy do zignorowania testu i ten test nie zostanie wykonany.

Utwórz plik klasy Java o nazwie JunitAnnotation.java w C: \> JUNIT_WORKSPACE, aby przetestować adnotację.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class JunitAnnotation {
	
   //execute before class
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute after class
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute before test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute after test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case
   @Test
   public void test() {
      System.out.println("in test");
   }
	
   //test case ignore and will not execute
   @Ignore
   public void ignoreTest() {
      System.out.println("in ignore test");
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać adnotacje.

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(JunitAnnotation.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

in before class
in before
in test
in after
in after class
true

W tym rozdziale wyjaśniono procedurę wykonywania metod w JUnit, która definiuje kolejność wywoływanych metod. Poniżej omówiono procedurę wykonania metod testowego API JUnit wraz z przykładem.

Utwórz plik klasy Java o nazwie ExecutionProcedureJunit.java w C: \> JUNIT_WORKSPACE, aby przetestować adnotacje.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class ExecutionProcedureJunit {
	
   //execute only once, in the starting 
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute for each test, after executing test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }
}

Następnie utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać adnotacje.

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(ExecutionProcedureJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

Zobacz powyższe dane wyjściowe. Procedura wykonania jest następująca -

Przede wszystkim metoda beforeClass () jest wykonywana tylko raz.
Metoda afterClass () jest wykonywana tylko raz.
Metoda before () jest wykonywana dla każdego przypadku testowego, ale przed wykonaniem przypadku testowego.
Metoda after () jest wykonywana dla każdego przypadku testowego, ale po wykonaniu przypadku testowego.
Każdy przypadek testowy jest wykonywany pomiędzy before () i after ().

Przypadki testowe są wykonywane przy użyciu JUnitCoreklasa. JUnitCore to fasada do przeprowadzania testów. Obsługuje testy JUnit 4, testy JUnit 3.8.xi mieszanki. Aby uruchomić testy z wiersza poleceń, uruchom java org.junit.runner.JUnitCore <TestClass>. W przypadku jednorazowych przebiegów testowych użyj statycznej metody runClasses (Class []).

Poniżej znajduje się deklaracja dla org.junit.runner.JUnitCore klasa:

public class JUnitCore extends java.lang.Object

Tutaj zobaczymy, jak wykonać testy za pomocą JUnitCore.

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy MessageUtil.java, w C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
	
}

Utwórz klasę przypadku testowego

Utwórz klasę testową Java, na przykład TestJunit.java.
Dodaj metodę testową testPrintMessage () do swojej klasy testowej.
Dodaj Annotaion @Test do metody testPrintMessage ().
Zaimplementuj warunek testowy i sprawdź warunek za pomocą funkcji API assertEquals JUnit.

Utwórz plik klasy Java o nazwie TestJunit.java w C: \> JUNIT_WORKSPACE.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Utwórz testową klasę biegacza

Teraz utwórz plik klasy java o nazwie TestRunner.javaw C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy. Importuje klasę JUnitCore i używa metody runClasses (), która jako parametr przyjmuje nazwę klasy testowej.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

Hello World
true

Test suitesłuży do spakowania kilku przypadków testów jednostkowych i uruchomienia ich razem. W JUnit oba@RunWith i @Suiteadnotacje są używane do uruchamiania testów zestawu. W tym rozdziale przedstawiono przykład dwóch klas testowych,TestJunit1 & TestJunit2, które działają razem przy użyciu Test Suite.

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy MessageUtil.java w C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Utwórz klasy przypadków testowych

Utwórz plik klasy Java o nazwie TestJunit1.java w C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

Utwórz plik klasy Java o nazwie TestJunit2.java w C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Utwórz klasę zestawu testów

Utwórz klasę Java.
Dołącz adnotację @RunWith (Suite.class) do klasy.
Dodaj odwołanie do klas testowych JUnit za pomocą adnotacji @ Suite.SuiteClasses.

Utwórz plik klasy Java o nazwie TestSuite.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
   TestJunit1.class,
   TestJunit2.class
})

public class JunitTestSuite {   
}

Utwórz testową klasę biegacza

Utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(JunitTestSuite.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj wszystkie klasy Java za pomocą javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadek testowy zdefiniowany w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

Czasami zdarza się, że nasz kod nie jest w pełni gotowy podczas uruchamiania przypadku testowego. W rezultacie przypadek testowy kończy się niepowodzeniem. Plik@Ignore adnotacja pomaga w tym scenariuszu.

Metoda testowa z adnotacją @Ignore nie zostanie wykonana.
Jeśli klasa testowa ma adnotację @Ignore, żadna z jej metod testowych nie zostanie wykonana.

Zobaczmy teraz @Ignore w akcji.

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy MessageUtil.java w C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
	
}

Utwórz klasę przypadku testowego

Utwórz klasę testową Java, na przykład TestJunit.java.
Dodaj metodę testową testPrintMessage () lub testSalutationMessage () do swojej klasy testowej.
Dodaj Annotaion @Ignore do metody testPrintMessage ().

Utwórz plik klasy Java o nazwie TestJunit.java w C: \ JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Ignore
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Utwórz testową klasę biegacza

Utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(TestJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy MessageUtil, Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Teraz uruchom Test Runner, który nie uruchomi przypadku testowego testPrintMessage () zdefiniowanego w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe. Przypadek testowy testPrintMessage () nie jest testowany.

Inside testSalutationMessage()
Hi!Robert
true

Teraz zaktualizuj TestJunit w C: \> JUNIT_WORKSPACE, aby zignorować wszystkie przypadki testowe. Dodaj @Ignore na poziomie klasy.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

@Ignore
public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
     
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Skompiluj przypadek testowy przy użyciu javac.

C:\JUNIT_WORKSPACE>javac TestJunit.java

Zachowaj swojego testera bez zmian w następujący sposób -

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Teraz uruchom Test Runner, który nie uruchomi żadnego przypadku testowego zdefiniowanego w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe. Żaden przypadek testowy nie jest testowany.

true

JUnit zapewnia przydatną opcję Timeout. Jeśli przypadek testowy trwa dłużej niż określona liczba milisekund, JUnit automatycznie oznaczy go jako zakończony niepowodzeniem. Pliktimeoutparametr jest używany wraz z adnotacją @Test. Zobaczmy, jak działa @Test (timeout).

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy MessageUtil.java w C: \> JUNIT_WORKSPACE.

Dodaj nieskończoną pętlę while wewnątrz metody printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      while(true);
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Utwórz klasę przypadku testowego

Utwórz klasę testową java, powiedzmy, TestJunit.java. Dodaj limit czasu równy 1000 do przypadku testowego testPrintMessage ().

Utwórz plik klasy Java o nazwie TestJunit.java w C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(timeout = 1000)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Utwórz testową klasę biegacza

Utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy MessageUtil, Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadki testowe zdefiniowane w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe. Przypadek testowy testPrintMessage () oznacza, że testy jednostkowe zakończyły się niepowodzeniem.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milliseconds
false

JUnit udostępnia opcję śledzenia obsługi wyjątków kodu. Możesz sprawdzić, czy kod zgłasza żądany wyjątek, czy nie. Plikexpectedparametr jest używany wraz z adnotacją @Test. Zobaczmy @Test (oczekiwany) w akcji.

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy MessageUtil.java w C: \> JUNIT_WORKSPACE.

Dodaj warunek błędu wewnątrz metody printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      int a = 0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Utwórz klasę przypadku testowego

Utwórz klasę testową Java o nazwie TestJunit.java. Dodaj oczekiwany wyjątek ArithmeticException do przypadku testowego testPrintMessage ().

Utwórz plik klasy Java o nazwie TestJunit.java w C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(expected = ArithmeticException.class)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Utwórz testową klasę biegacza

Utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy MessageUtil, Test case i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadki testowe zdefiniowane w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe. Przypadek testowy testPrintMessage () zostanie zaliczony.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true

JUnit 4 wprowadził nową funkcję o nazwie parameterized tests. Testy sparametryzowane pozwalają programistom na wielokrotne uruchamianie tego samego testu przy użyciu różnych wartości. Aby utworzyć sparametryzowany test, należy wykonać pięć kroków.

Opisz klasę testową za pomocą @RunWith (Parameterized.class).
Utwórz publiczną metodę statyczną z adnotacją @Parameters, która zwraca Collection of Objects (as Array) jako zestaw danych testowych.
Utwórz konstruktor publiczny, który pobierze odpowiednik jednego „wiersza” danych testowych.
Utwórz zmienną instancji dla każdej „kolumny” danych testowych.
Utwórz przypadki testowe, używając zmiennych instancji jako źródła danych testowych.

Przypadek testowy zostanie wywołany raz dla każdego wiersza danych. Zobaczmy, jak działają sparametryzowane testy.

Utwórz klasę

Utwórz klasę Java do przetestowania, powiedzmy PrimeNumberChecker.java w C: \> JUNIT_WORKSPACE.

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Utwórz sparametryzowaną klasę przypadku testowego

Utwórz klasę testową java, powiedzmy, PrimeNumberCheckerTest.java. Utwórz plik klasy Java o nazwiePrimeNumberCheckerTest.java w C: \> JUNIT_WORKSPACE.

import java.util.Arrays;
import java.util.Collection;
 
import org.junit.Test;
import org.junit.Before;

import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
   private Integer inputNumber;
   private Boolean expectedResult;
   private PrimeNumberChecker primeNumberChecker;

   @Before
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   // Each parameter should be placed as an argument here
   // Every time runner triggers, it will pass the arguments
   // from parameters we defined in primeNumbers() method
	
   public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
      this.inputNumber = inputNumber;
      this.expectedResult = expectedResult;
   }

   @Parameterized.Parameters
   public static Collection primeNumbers() {
      return Arrays.asList(new Object[][] {
         { 2, true },
         { 6, false },
         { 19, true },
         { 22, false },
         { 23, true }
      });
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test
   public void testPrimeNumberChecker() {
      System.out.println("Parameterized Number is : " + inputNumber);
      assertEquals(expectedResult, 
      primeNumberChecker.validate(inputNumber));
   }
}

Utwórz testową klasę biegacza

Utwórz plik klasy Java o nazwie TestRunner.java w C: \> JUNIT_WORKSPACE, aby wykonać przypadek testowy.

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(PrimeNumberCheckerTest.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Skompiluj klasy PrimeNumberChecker, PrimeNumberCheckerTest i Test Runner przy użyciu javac.

C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java

Teraz uruchom Test Runner, który uruchomi przypadki testowe zdefiniowane w podanej klasie Test Case.

C:\JUNIT_WORKSPACE>java TestRunner

Sprawdź dane wyjściowe.

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true

Będziemy mieć przykład pokazujący, jak uruchomić JUnit za pomocą ANT. Wykonaj czynności podane poniżej.

Krok 1: Pobierz Apache Ant

Pobierz Apache Ant na podstawie systemu operacyjnego, na którym pracujesz.

OS	Nazwa archiwum
Windows	apache-ant-1.8.4-bin.zip
Linux	apache-ant-1.8.4-bin.tar.gz
Prochowiec	apache-ant-1.8.4-bin.tar.gz

Krok 2: Ustaw środowisko mrówki

Ustaw ANT_HOMEzmienna środowiskowa wskazująca lokalizację katalogu podstawowego, w którym na komputerze są przechowywane biblioteki ANT. Załóżmy, że biblioteki Ant są przechowywane w folderze apache-ant-1.8.4.

Sr.No.	System operacyjny i opis
1	Windows Ustaw zmienną środowiskową ANT_HOME na C: \ Program Files \ Apache Software Foundation \ apache-ant-1.8.4
2	Linux eksportuj ANT_HOME = /usr/local/apache-ant-1.8.4
3	Mac eksportuj ANT_HOME = /Library/apache-ant-1.8.4

Dołącz lokalizację kompilatora Ant do ścieżki systemowej w następujący sposób -

OS	Wynik
Windows	Dołącz ciąg %ANT_HOME\bin na końcu zmiennej systemowej, Path.
Linux	eksportuj PATH = $PATH:$ANT_HOME / bin /
Prochowiec	nie wymagane

Krok 3: Pobierz archiwum JUnit

Pobierz archiwum JUnit, które pasuje do Twojego systemu operacyjnego.

OS	Nazwa archiwum
Windows	junit4.10.jar
Linux	junit4.10.jar
Prochowiec	junit4.10.jar

Krok 4: Utwórz strukturę projektu

Utwórz folder TestJunitWithAnt w C: \> JUNIT_WORKSPACE.
Utwórz folder src w C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Utwórz folder test w C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Utwórz folder lib w C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Stwórz MessageUtil class w C: \> JUNIT_WORKSPACE> TestJunitWithAnt> srcfolder.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Stwórz TestMessageUtil class w folderze C: \> JUNIT_WORKSPACE> TestJunitWithAnt> src.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestMessageUtil {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Skopiuj junit-4.10.jar do folderu C: \> JUNIT_WORKSPACE> TestJunitWithAnt> lib.

Utwórz plik ANT Build.xml

Będziemy używać <junit> zadanie w Ant, aby wykonać nasze przypadki testowe JUnit.

<project name = "JunitTest" default = "test" basedir = ".">
   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "full-compile" value = "true" />
	
   <path id = "classpath.base"/>
	
   <path id = "classpath.test">
      <pathelement location = "lib/junit-4.10.jar" />
      <pathelement location = "${testdir}" /> <pathelement location = "${srcdir}" />
      <path refid = "classpath.base" />
   </path>
	
   <target name = "clean" >
      <delete verbose = "${full-compile}"> <fileset dir = "${testdir}" includes = "**/*.class" />
      </delete>
   </target>
	
   <target name = "compile" depends = "clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" 
         verbose = "${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
	
   <target name = "test" depends = "compile">
      <junit>
         <classpath refid = "classpath.test" />
         <formatter type = "brief" usefile = "false" />
         <test name = "TestMessageUtil" />
      </junit>
   </target>
	
</project>

Uruchom następujące polecenie Ant.

C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant

Sprawdź dane wyjściowe.

Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml

clean:  

compile:  
   [javac] Compiling 2 source files to C:\JUNIT_WORKSPACE\TestJunitWithAnt\test
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      MessageUtil.java]
   [javac] [parsing completed 18ms]
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      TestMessageUtil.java]
   [javac] [parsing completed 2ms]
   [javac] [search path for source files: C:\JUNIT_WORKSPACE\
      TestJunitWithAnt\src]    
   [javac] [loading java\lang\Object.class(java\lang:Object.class)]
   [javac] [loading java\lang\String.class(java\lang:String.class)]
   [javac] [loading org\junit\Test.class(org\junit:Test.class)]
   [javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)]
   [javac] [loading org\junit\Assert.class(org\junit:Assert.class)]
   [javac] [loading java\lang\annotation\Retention.class
      (java\lang\annotation:Retention.class)]
   [javac] [loading java\lang\annotation\RetentionPolicy.class
      (java\lang\annotation:RetentionPolicy.class)]
   [javac] [loading java\lang\annotation\Target.class
      (java\lang\annotation:Target.class)]
   [javac] [loading java\lang\annotation\ElementType.class
      (java\lang\annotation:ElementType.class)]
   [javac] [loading java\lang\annotation\Annotation.class
      (java\lang\annotation:Annotation.class)]
   [javac] [checking MessageUtil]
   [javac] [loading java\lang\System.class(java\lang:System.class)]
   [javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)]
   [javac] [loading java\io\FilterOutputStream.class
      (java\io:FilterOutputStream.class)]
   [javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)]
   [javac] [loading java\lang\StringBuilder.class
      (java\lang:StringBuilder.class)]
   [javac] [loading java\lang\AbstractStringBuilder.class
      (java\lang:AbstractStringBuilder.class)]
   [javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)]
   [javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
   [javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)]
   [javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class]
   [javac] [checking TestMessageUtil]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class]
   [javac] [total 281ms]

test:
    [junit] Testsuite: TestMessageUtil
    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
    [junit]
    [junit] ------------- Standard Output ---------------
    [junit] Inside testPrintMessage()
    [junit] Robert
    [junit] Inside testSalutationMessage()
    [junit] Hi!Robert
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 0 seconds

Aby skonfigurować JUnit z eclipse, wykonaj kroki podane poniżej.

Krok 1: Pobierz archiwum JUnit

Pobierz plik JUnit oparty na systemie operacyjnym, który masz w swoim systemie.

OS	Nazwa archiwum
Windows	junit4.10.jar
Linux	junit4.10.jar
Prochowiec	junit4.10.jar

Załóżmy, że skopiowałeś powyższy plik JAR do folderu C: \> JUnit.

Krok 2: Ustaw środowisko Eclipse

Otwórz eclipse → kliknij prawym przyciskiem myszy projekt i kliknij właściwość> Build Path> Configure Build Path i dodaj junit-4.10.jar do bibliotek za pomocą przycisku Add External Jar.

Zakładamy, że Twój Eclipse ma wbudowaną wtyczkę JUnit. Jeśli nie jest dostępny w katalogu C: \> eclipse \ plugins, możesz go pobrać zJUnit Plugin. Rozpakuj pobrany plik zip w folderze wtyczek Eclipse. Na koniec uruchom ponownie Eclipse.

Teraz Twój Eclipse jest gotowy do tworzenia przypadków testowych JUnit.

Krok 3: Zweryfikuj instalację JUnit w Eclipse

Utwórz projekt TestJunitw Eclipse w dowolnym miejscu. Następnie utwórz klasęMessageUtil do przetestowania w projekcie.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Utwórz klasę testową TestJunit w projekcie.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	  
      assertEquals(message,messageUtil.printMessage());
   }
}

Poniżej powinna być struktura projektu -

Na koniec kliknij program prawym przyciskiem myszy i uruchom jako JUnit, aby zweryfikować dane wyjściowe programu.

Sprawdź wynik.

Poniżej znajdują się rozszerzenia JUnit -

Cactus
JWebUnit
XMLUnit
MockObject

Kaktus

Cactus to prosta struktura testowa do testowania jednostkowego kodu Java po stronie serwera (serwlety, EJB, tagi, filtry). Celem Cactus jest obniżenie kosztów pisania testów dla kodu po stronie serwera. Używa JUnit i rozszerza go. Cactus implementuje strategię w kontenerze, która wykonuje testy wewnątrz kontenera.

Ekosystem kaktusa składa się z kilku elementów -

Cactus Frameworkjest sercem Cactus. Jest to silnik, który zapewnia API do pisania testów Cactus.
Cactus Integration Modules to front-endy i frameworki, które zapewniają łatwe sposoby używania Cactus Framework (skrypty Ant, wtyczka Eclipse i wtyczka Maven).

Poniższy kod ilustruje, jak można użyć Cactus.

import org.apache.cactus.*;
import junit.framework.*;

public class TestSampleServlet extends ServletTestCase {
   @Test
   public void testServlet() {
      // Initialize class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit to oparty na języku Java framework do testowania aplikacji internetowych. Obejmuje istniejące struktury testowe, takie jak HtmlUnit i Selenium, z ujednoliconym, prostym interfejsem testowym do testowania poprawności aplikacji internetowych.

JWebUnit zapewnia wysokopoziomowy interfejs API języka Java do nawigacji w aplikacji internetowej w połączeniu z zestawem asercji w celu weryfikacji poprawności aplikacji. Obejmuje to nawigację za pomocą łączy, wprowadzanie i przesyłanie formularzy, sprawdzanie zawartości tabel i inne typowe funkcje aplikacji internetowych dla firm.

Proste metody nawigacji i gotowe do użycia asercje pozwalają na szybsze tworzenie testów niż używanie tylko JUnit lub HtmlUnit. A jeśli chcesz przełączyć się z HtmlUnit na inne wtyczki, takie jak Selenium (dostępne wkrótce), nie ma potrzeby przepisywania testów.

Oto przykładowy kod.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

public class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   public ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   public void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   public void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit udostępnia pojedynczą klasę rozszerzenia JUnit, XMLTestCase i zestaw klas pomocniczych, które umożliwiają tworzenie asercji dotyczących -

Różnice między dwoma fragmentami XML (poprzez klasy Diff i DetailedDiff).
Ważność fragmentu XML (poprzez klasę Validator).
Wynik przekształcenia fragmentu XML za pomocą XSLT (za pośrednictwem klasy Transform).
Ocena wyrażenia XPath na fragmencie XML (za pośrednictwem klas implementujących interfejs XpathEngine).
Poszczególne węzły w kawałku XML, które są ujawniane przez DOM Traversal (za pośrednictwem klasy NodeTest).

Załóżmy, że mamy dwa fragmenty XML, które chcemy porównać i stwierdzić, że są równe. Moglibyśmy napisać taką prostą klasę testową -

import org.custommonkey.xmlunit.XMLTestCase;

public class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   public void testForXMLEquality() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

W teście jednostkowym pozorowane obiekty mogą symulować zachowanie złożonych, rzeczywistych (nie-pozorowanych) obiektów i dlatego są przydatne, gdy rzeczywisty obiekt jest niepraktyczny lub niemożliwy do włączenia do testu jednostkowego.

Typowy styl kodowania do testowania przy użyciu pozorowanych obiektów to -

Twórz instancje pozorowanych obiektów.
Ustaw stan i oczekiwania w obiektach pozornych.
Wywołaj kod domeny z pozorowanymi obiektami jako parametrami.
Sprawdź spójność w obiektach pozorowanych.

Poniżej podano przykład MockObject przy użyciu Jmocka.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   public void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.publish(message);
      
      // verify
      context.assertIsSatisfied();
   }
}