Difference between @Before, @BeforeClass, @BeforeEach and @BeforeAll
The code marked @Before is executed before each test, while @BeforeClass runs once before the entire test fixture. If your test class has ten tests, @Before code will be executed ten times, but @BeforeClass will be executed only once.
In general, you use @BeforeClass when multiple tests need to share the same computationally expensive setup code. Establishing a database connection falls into this category. You can move code from @BeforeClass into @Before, but your test run may take longer. Note that the code marked @BeforeClass is run as static initializer, therefore it will run before the class instance of your test fixture is created.
In JUnit 5, the tags @BeforeEach and @BeforeAll are the equivalents of @Before and @BeforeClass in JUnit 4. Their names are a bit more indicative of when they run, loosely interpreted: 'before each tests' and 'once before all tests'.
Difference between each annotation are :
+-------------------------------------------------------------------------------------------------------+¦ Feature ¦ Junit 4 ¦ Junit 5 ¦¦--------------------------------------------------------------------------+--------------+-------------¦¦ Execute before all test methods of the class are executed. ¦ @BeforeClass ¦ @BeforeAll ¦¦ Used with static method. ¦ ¦ ¦¦ For example, This method could contain some initialization code ¦ ¦ ¦¦-------------------------------------------------------------------------------------------------------¦¦ Execute after all test methods in the current class. ¦ @AfterClass ¦ @AfterAll ¦¦ Used with static method. ¦ ¦ ¦¦ For example, This method could contain some cleanup code. ¦ ¦ ¦¦-------------------------------------------------------------------------------------------------------¦¦ Execute before each test method. ¦ @Before ¦ @BeforeEach ¦¦ Used with non-static method. ¦ ¦ ¦¦ For example, to reinitialize some class attributes used by the methods. ¦ ¦ ¦¦-------------------------------------------------------------------------------------------------------¦¦ Execute after each test method. ¦ @After ¦ @AfterEach ¦¦ Used with non-static method. ¦ ¦ ¦¦ For example, to roll back database modifications. ¦ ¦ ¦+-------------------------------------------------------------------------------------------------------+Most of annotations in both versions are same, but few differs.
Order of Execution.
Dashed box -> optional annotation.
Before and BeforeClass in JUnit
The function @Before annotation will be executed before each of test function in the class having @Test annotation but the function with @BeforeClass will be execute only one time before all the test functions in the class.
Similarly function with @After annotation will be executed after each of test function in the class having @Test annotation but the function with @AfterClass will be execute only one time after all the test functions in the class.
SampleClass
public class SampleClass { public String initializeData(){ return "Initialize"; } public String processDate(){ return "Process"; } }SampleTest
public class SampleTest { private SampleClass sampleClass; @BeforeClass public static void beforeClassFunction(){ System.out.println("Before Class"); } @Before public void beforeFunction(){ sampleClass=new SampleClass(); System.out.println("Before Function"); } @After public void afterFunction(){ System.out.println("After Function"); } @AfterClass public static void afterClassFunction(){ System.out.println("After Class"); } @Test public void initializeTest(){ Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() ); } @Test public void processTest(){ Assert.assertEquals("Process check", "Process", sampleClass.processDate() ); }}Output
Before ClassBefore FunctionAfter FunctionBefore FunctionAfter FunctionAfter ClassIn Junit 5
@Before = @BeforeEach@BeforeClass = @BeforeAll@After = @AfterEach@AfterClass = @AfterAll