[JAVA] Résumé personnel des types souvent utilisés dans JUnit 4

introduction

[Introduction à JUnit Practice](https://www.amazon.co.jp/JUnit%E5%AE%9F%E8%B7%B5%E5%85%A5%E9%96%80-~%E4%BD% 93% E7% B3% BB% E7% 9A% 84% E3% 81% AB% E5% AD% A6% E3% 81% B6% E3% 83% A6% E3% 83% 8B% E3% 83% 83% E3% 83% 88% E3% 83% 86% E3% 82% B9% E3% 83% 88% E3% 81% AE% E6% 8A% 80% E6% B3% 95-WEB-PRESS-plus / dp / Si vous avez 477415377X), il n'y a rien de mal à cela, mais je ne l'ai souvent pas, donc je ne résumerai que ceux qui l'utilisent souvent.

De base

@Test
public void test1() {
	String actual = "hoge";
	String expected = "hoge";
	assertThat(actual, is(expected));
}

@Test
public void test2() {
	String actual = null;
	assertThat(actual, is(nullValue()));
}

@Before
public void setUp() throws Exception {
}

@After
public void tearDown() throws Exception {
}

@BeforeClass
public static void setUpBeforeClass() throws Exception {
}

@AfterClass
public static void tearDownAfterClass() throws Exception {
}

La méthode annotée avec «@ Test» est la méthode de test réelle. ʻAssertThat () compare la valeur attendue avec la valeur réelle. Dans l'exemple, ʻis () etnullValue ()sont utilisés, mais en plus,not ()est utilisé.

«@ Before» est exécuté avant que chaque méthode de «@ Test» ne soit exécutée, et «@ After» est exécuté après que chaque méthode de «@ Test» soit exécutée. S'il existe un processus commun à chaque test, tel que la connexion et la déconnexion au DB, vous pouvez l'écrire ici.

@ BeforeClass est exécuté une seule fois avant que toutes les méthodes @ Test soient exécutées, et @ AfterClass est exécuté une seule fois après que toutes les méthodes @ Test aient été exécutées. @ BeforeClass est utilisé lors de la sélection des paramètres de test dans les fichiers de propriétés. Je ne pense pas que j'utilise beaucoup @ AfterClass ...

Dans l'exemple, rien n'est écrit comme @ Before, mais vous pouvez écrire un test ici avec ʻassertThat ()`. Vous pouvez également tester l'état avant et après chaque processus.

Lors de la division du test en plusieurs parties

@RunWith(Enclosed.class)
public class JUnitTest {

	public static class TestClass1 {
		@Before
		public void setUp() throws Exception {
			//Pré-traitement pour la classe d'essai 1
		}

		@After
		public void tearDown() throws Exception {
			//Post-traitement pour la classe d'essai 1
		}

		@Test
		public void test() {
			String actual = "hoge";
			String expected = "hoge";
			assertThat(actual, is(expected));
		}
	}
	
	public static class TestClass2 {
		@Before
		public void setUp() throws Exception {
			//Prétraitement pour la classe d'essai 2
		}

		@After
		public void tearDown() throws Exception {
			//Post-traitement pour la classe d'essai 2
		}

		@Test
		public void test() {
			String actual = "fuge";
			String expected = "fuge";
			assertThat(actual, is(expected));
		}
	}

}

Si le prétraitement est différent pour chaque test, ajoutez @RunWith (Enclosed.class) à la classe de test, puis créez une classe interne. Dans l'exemple, «TestClass1» et «TestClass2» peuvent exécuter différents prétraitements et post-traitements. C'est pratique, mais j'oublie comment écrire l'annotation @RunWith (Enclosed.class) à chaque fois.

Lors de la répétition de tests similaires

@RunWith(Theories.class)
public class JUnitTest {

	@DataPoints
	public static String[] actualValues = {"hoge", "fuge"};

	@Theory
	public void test(String actualValue) {
		int actual = actualValue.length();
		int expected = 4;
		assertThat(actual, is(expected));
	}

}

S'il existe plusieurs tests avec des formats d'entrée et de sortie similaires, il est préférable de les assembler dans une certaine mesure. Spécifiez @RunWith (Theories.class) pour la classe de test et @ Theory au lieu de @ Test pour la méthode de test. Si vous mettez l'entrée et la sortie du test dans un tableau de @ DataPoints et que vous spécifiez la valeur du type spécifié par @ DataPoints dans l'argument de la méthode de @ Theory, ce sera @ Theory. Lorsque la méthode est exécutée, le test est exécuté pour le nombre de tableaux de @ DataPoints.