JUnit - Testy jednostkowe w Javie

Wprowadzenie do JUnitów

Przez całe studia napisałem już sporo aplikacji, lecz zawsze pomijałem aspekt ich testowania. Muszę się przyznać, że dopiero od niedawna zacząłem używać JUnitów, które wbrew pozorom znacznie przyspieszają pracę.

JUnit to test jednostkowy, który docelowo sprawdzają, czy dana funkcjonalność działa zgodnie z jej przeznaczeniem. Dobrą praktyką jest dzielenie JUnitów, tak aby testowały one tylko wybraną metodę lub funkcjonalność, zaczynając od tych najprostszych, do coraz bardziej zaawansowanych.

Instalacja

Jeśli korzystamy z eclipse, to nie jest wymagana żadna dodatkowa wtyczka, ani biblioteka. Jeśli natomiast korzystasz z innego narzędzia, będziesz musisz sobie niestety poradzić samodzielnie :)

Przykład użycia - gra w życie

Pokażę Wam przykład podejścia do JUnitów na przykładzie gry w życie. Opis gry dostępny jest na wikipedii.

Gra odbywa się w turach, na nieskończenie wielkiej planszy. Każde pole planszy może być "żywe" albo "martwe". Stan pola może zmienić się po turze w zależności od stanu jego sąsiadów:

1. Jeśli żywa komórka ma mniej niż 2 sąsiadów ginie z samotności

2. Jeżeli żywa komórka ma 2 albo 3 żywych sąsiadów przeżyje do następnej tury

3. Jeżeli żywa komórka ma więcej niż 3 sąsiadów ginie z przeludnienia

4. Jeśli martwa komórka ma dokładnie 3 sąsiadów, ożywa

Bardzo proste zasady, świetnie można zastosować dla nich JUnity. Implementacji może być całkiem sporo, niżej przestawią przykładową.

Cell.java

package game;
 
 public class Cell implements Cloneable {
 
 	private boolean alive;
 
 	public Cell(boolean alive) {
 		this.setAlive(alive);
 	}
 
 	public boolean isAlive() {
 		return alive;
 	}
 
 	public void setAlive(boolean alive) {
 		this.alive = alive;
 	}
 
 	@Override
 	public Cell clone() {
 		return new Cell(alive);
 	}
 
 	public void changeState(int neighboursCount) {
 
 		if (alive) {
 
 			if (neighboursCount < 2) {
 				alive = false;
 			} else if (neighboursCount > 3) {
 				alive = false;
 			}
 
 		} else {
 
 			if (neighboursCount == 3) {
 				alive = true;
 			}
 
 		}
 
 	}
 
 }

Board.java

package game;
 
 public class Board {
 
 	private Cell[][] cells;
 	private int width;
 	private int height;
 
 	public Board(int width, int height) {
 		this.width = width;
 		this.height = height;
 		cells = new Cell[width][height];
 		resetAll();
 	}
 
 	// reset calej planszy
 	private void resetAll() {
 		for (int i = 0; i < width; i++) {
 			for (int j = 0; j < height; j++) {
 				cells[i][j] = new Cell(false);
 			}
 		}
 	}
 
 	// ustawienie wartosci komorki
 	public void setCellValue(int x, int y, boolean isAlive) {
 		if (x >= 0 && y >= 0 && x < width && y < height) {
 			cells[x][y].setAlive(isAlive);
 		} else {
 			throw new IndexOutOfBoundsException();
 		}
 	}
 
 	// pobranie wartosci komorki
 	public boolean getCellValue(int x, int y) {
 		if (x >= 0 && y >= 0 && x < width && y < height) {
 			return cells[x][y].isAlive();
 		} else {
 			throw new IndexOutOfBoundsException();
 		}
 	}
 
 	// wykonanie aktualnej tury
 	public void nextCycle() {
 
 		// kopiowanie aktualnego stanu
 		Cell[][] newBoard = new Cell[width][height];
 		for (int i = 0; i < width; i++) {
 			for (int j = 0; j < height; j++) {
 				newBoard[i][j] = cells[i][j].clone();
 			}
 		}
 
 		// wykonanie akcji dla danej komorki
 		for (int i = 0; i < width; i++) {
 			for (int j = 0; j < height; j++) {
 				int neighboursCount = countAliveNeighbours(i, j);
 				newBoard[i][j].changeState(neighboursCount);
 			}
 		}
 
 		cells = newBoard;
 	}
 
 	// liczenie zywych sasiadow
 	public int countAliveNeighbours(int i, int j) {
 		int startX = Math.max(i - 1, 0);
 		int startY = Math.max(j - 1, 0);
 		int endX = Math.min(i + 1, width - 1);
 		int endY = Math.min(j + 1, height - 1);
 
 		int aliveNeighbours = 0;
 		for (int x = startX; x <= endX; x++) {
 			for (int y = startY; y <= endY; y++) {
 
 				if (cells[x][y].isAlive()) {
 					aliveNeighbours++;
 				}
 
 			}
 		}
 
 		// nie liczymy komorki ktorej sasiadow sprawdzamy
 		if (cells[i][j].isAlive()) {
 			aliveNeighbours--;
 		}
 
 		return aliveNeighbours;
 	}
 
 }

Kod programu raczej mało skomplikowany i nie wymaga dalszego komentarza. Teraz przejdźmy do jego testowania.

Stwórz nowy pakiet dla testów, kliknij na niego prawym przyciskiem myszy i wybierz New->Other...

Wygenerowana zostanie klasa z jedną metodą. Sami musimy stworzyć odpowiednie metody testujące.

Testy muszą spełnić zasady:

• oznaczone znacznikiem @org.junit.Test
• oznaczone jako metody publiczne (public)
• zaczynać się od test

Korzystamy z asercji takich jak: assertEquals(), assertNotEquals(), assertNull(), assertNotNull() itd. Metod tych jest naprawdę sporo, a ich nazwy dosyć łatwo skojarzyć z funkcją którą pełnią.

Poniżej moja klasa testowa.

Test.java

package test;
 
 import game.Board;
 import junit.framework.Assert;
 
 public class Test {
 
 	@org.junit.Test
 	public void testCreate() {
 
 		int width = 10;
 		int height = 10;
 		Board board = new Board(width, height);
 		Assert.assertNotNull(board);
 
 		for (int i = 0; i < width; i++) {
 			for (int j = 0; j < height; j++) {
 				Assert.assertEquals(false, board.getCellValue(i, j));
 			}
 		}
 	}
 
 	@org.junit.Test
 	public void testSetValue() {
 		Board board = new Board(10, 10);
 		board.setCellValue(5, 5, true);
 		Assert.assertEquals(true, board.getCellValue(5, 5));
 
 		board.setCellValue(0, 0, true);
 		Assert.assertEquals(true, board.getCellValue(0, 0));
 
 		board.setCellValue(0, 1, true);
 		Assert.assertEquals(true, board.getCellValue(0, 1));
 
 		board.setCellValue(1, 0, true);
 		Assert.assertEquals(true, board.getCellValue(1, 0));
 
 		board.setCellValue(1, 1, true);
 		Assert.assertEquals(true, board.getCellValue(1, 1));
 	}
 
 	@org.junit.Test
 	public void testDieLonely() {
 
 		// zero sasiadow
 		Board board = new Board(5, 5);
 		board.setCellValue(0, 0, true);
 		Assert.assertEquals(0, board.countAliveNeighbours(0, 0));
 		board.nextCycle();
 		Assert.assertEquals(false, board.getCellValue(0, 0));
 
 		// jeden sasiad
 		Board board2 = new Board(5, 5);
 		board2.setCellValue(0, 0, true);
 		board2.setCellValue(0, 1, true);
 		Assert.assertEquals(1, board2.countAliveNeighbours(0, 0));
 		board2.nextCycle();
 		Assert.assertEquals(false, board2.getCellValue(0, 0));
 
 	}
 
 	@org.junit.Test
 	public void testSurvive() {
 
 		// dwoch sasiadow
 		Board board2 = new Board(5, 5);
 		board2.setCellValue(0, 0, true);
 		board2.setCellValue(0, 1, true);
 		board2.setCellValue(1, 0, true);
 		Assert.assertEquals(2, board2.countAliveNeighbours(0, 0));
 		board2.nextCycle();
 		Assert.assertEquals(true, board2.getCellValue(0, 0));
 
 		// trzech sasiadow
 		Board board3 = new Board(5, 5);
 		board3.setCellValue(0, 0, true);
 		board3.setCellValue(0, 1, true);
 		board3.setCellValue(1, 0, true);
 		board3.setCellValue(1, 1, true);
 		Assert.assertEquals(3, board3.countAliveNeighbours(0, 0));
 		board3.nextCycle();
 		Assert.assertEquals(true, board3.getCellValue(0, 0));
 
 	}
 
 	@org.junit.Test
 	public void testDieOverpopulation() {
 
 		// czterech sasiadow
 		Board board = new Board(5, 5);
 		board.setCellValue(2, 2, true);
 		board.setCellValue(2, 1, true);
 		board.setCellValue(2, 3, true);
 		board.setCellValue(1, 2, true);
 		board.setCellValue(3, 2, true);
 		Assert.assertEquals(4, board.countAliveNeighbours(2, 2));
 		board.nextCycle();
 		Assert.assertEquals(false, board.getCellValue(2, 2));
 
 	}
 
 	@org.junit.Test
 	public void testRessurection() {
 
 		Board board = new Board(5, 5);
 		board.setCellValue(2, 2, false);
 		board.setCellValue(2, 1, true);
 		board.setCellValue(2, 3, true);
 		board.setCellValue(1, 2, true);
 		Assert.assertEquals(3, board.countAliveNeighbours(2, 2));
 		board.nextCycle();
 		Assert.assertEquals(true, board.getCellValue(2, 2));
 
 	}
 }

Jak zapewne zauważyliście zaczynam od testowania funkcji podstawowych, i przechodzę do testowania tych bardziej zaawansowanych (chociaż trudno mówić o zaawansowaniu w tym przypadku). Warto zwrócić uwagę na to, że dla każdej zasady gry tworzę osobny test sprawdzający jej poprawność.

Dobre praktyki, Test Driven Development

Doświadczenie zdobyte w firmie w której pracuję pomogło mi lepiej zrozumieć sposób w jaki powinny być tworzone JUnity.

• Każdy test powinien być niezależny od innego. W przykładzie powyżej możecie zauważyć, że dla każdego testu tworzę osobną planszę. Ma to na celu uniknięcie sytuacji w której mała zmiana w poprzednim teście powoduje wywalenie się testu który korzystał z tych samych danych.

• Często dochodzi do przypadków, gdzie danych testowych nie jesteśmy w stanie wypisać "z ręki" tak jak w przykładzie. Korzystamy wtedy z danych z bazy danych, serwera itd. Tutaj starajmy się zakładać, że nie wiemy ile tych danych będzie. Niepoprawne jest założenie, że powinno być np. 2 testowe konta użytkowników i sprawdzając ich unikatowość wystarczy je porównać. Co w przypadku, gdy ktoś doda, bądź usunie dane z bazy? Test się wywali i będzie trzeba szukać tego przyczyny, co czasami może być bardzo czasochłonne.

Można również pomyśleć o zastosowaniu TDD (Test Driven Development). Polega to w skrócie na tym, że najpierw koncentrujemy się na pisaniu JUnitów, a następnie zajmujemy się ich implementacją. Trochę ciężko się na przestawić, głównie ze względu na to, że pisanie testów jest żmudne i nudne, a w przypadku nowych projektów od razu się chce coś tworzyć. Mogę jednak z własnego doświadczenia zapewnić, że na dłuższą metę takie rozwiązanie jest zdecydowanie bardziej opłacalne nie tylko pod względem zaoszczędzonego czasu, ale przede wszystkim nerwów przy debugowaniu jakieś literówki.

Tyle na temat JUnitów z mojej strony. Jest to oczywiście bardzo obszerny temat, ale sądzę, że na początek taki krótki zarys wystarczy.