Java Testing Frameworks: Choosing the Right Tool for the Job - JUnit, AssertJ and Hamcrest

Testing is one of the most important aspects when building applications. Java has multiple testing frameworks which help to test different functionalities. But first, we need to have a good idea of why we are writing tests. Why Tests? When developing applications, it is possible to miss a certain logic or contain some bugs in the application. We are mainly writing tests to avoid those intricacies. Apart from that, testing also helps you to increase code quality, and it proves that your code is doing what you think it should be doing. Also, it proves that you are following the industry's best practices and other developers can get a good understanding of what your code does. Test Types When writing tests it is important to have an idea about the types of tests involved with testing. In this section, we will be looking at the most common test types and get a good grasp of what they mean. Unit Tests/ Unit Testing → These are tests that were written to test the specific sections of your code. These don’t have external dependencies and are intended to run very fast. Integration Tests / Integration Testing → These are tests that were written to test the behaviors between objects and parts of the overall system. These are usually written to cover a larger scope and are slower than unit tests. Functional Tests / Functional Testing → These tests are for testing the running application. Usually, functional touch points are tested in these tests (e.g. calling web services, sending/receiving messages, etc.). It is important to note that all three types of tests play important roles in software quality. Therefore, it is better to use a combination of the above tests to increase your code quality. JUnit When it comes to writing unit tests in Java, the defacto framework that most developers use is JUnit. There are mainly three modules in JUnit which provide different functionalities. JUnit Platform → The foundation for launching testing frameworks on the JVM. This allows tests to be run from console launcher, or build tools such as Maven and Gradle. JUnit Jupiter → Programming model from writing tests and extensions to JUnit. JUnit Vintage → Provides a test engine for running JUnit 3 and JUnit 4 tests. When using JUnit, we are associating with quite a few annotations. Some of the most common JUnit annotations are shown below. → Marks a method as a test method. @Test → Marks method as a parameterized test. @ParameterizedTest → Repeat test N times. @RepeatedTest → Test factory method for dynamic tests. @TestFactory → Used to configure test instance lifecycle. @TestInstance → Creates a template to be used by multiple test cases. @TestTemplate → Human-friendly name for test. @DisplayName → Method to run before each test case. @BeforeEach → Method to run after each test case. @AfterEach → Static method to run before all test cases in the current class. @BeforeAll → Static method to run after all test cases in the current class. @AfterAll → Creates a nested test class. @Nested → Declares “tags” for filtering tests. @Tag → Disable a test or test class. @Disabled → Used to register extensions. @ExtendWith We will be looking at these extensively while developing a project. Getting hands dirty with JUnit Let’s create a new Maven project to test the above-mentioned annotations and get a good grasp of JUnit. We will not look at how you can install Java or Maven to your system in this article. To grasp how Java and Maven can be effortlessly set up, you can refer to this . We will be using IntelliJ IDEA as our IDE in this article. If you are not familiar with IntelliJ IDEA, you can use an IDE of your preference for this. article Part 1 - Project Setup Go to to create a new project. Since this is a simple project I have selected the following properties as shown in the image. IntelliJ IDEA → File → New → Project Although, I have created the project for Java 16 ( ) I need to use Java 17 in my project. So how can I fix this? To use Java 17 in your project, simply go to, and select Java 17 there. But, note that, to use Java 17, you need to have Java 17 SDK installed on your machine. corretto-16 File → Project Structure But, only changing this will not work, because you have to update the Java version in file as well. To update the Java version, go to and change the as shown below. pom.xml pom.xml properties 17 17 ... Now, let’s add JUnit to our project by adding JUnit dependency in the file. First, define the JUnit version we are using in the section as shown below. pom.xml properties ... 5.9.2 After that, define the dependencies by adding the following to the file. pom.xml org.junit.jupiter junit-jupiter-api ${junit-platform.version} test org.junit.jupiter junit-jupiter-engine ${junit-platform.version} test After that, add the build plugins by adding the following to the file. pom.xml org.apache.maven.plugins maven-compiler-plugin 3.11.0 org.apache.maven.plugins maven-surefire-plugin 3.1.2 org.apache.maven.plugins maven-failsafe-plugin 2.22.0 After that, you can sync the Maven settings from the IDE and test whether the project is working properly by double-clicking on the lifecycle dependency (Alternatively you can run in your terminal as well). test mvn clean test Since we are creating a small project, we will create a new file in named with basic arithmetic operations(+,-,/,*) written there. org.nipunaupeksha.junit5 SimpleCalculator package org.nipunaupeksha;

public class SimpleCalculator { public double add(double numberA, double numberB) { return numberA + numberB; }

public double subtract(double numberA, double numberB) { return numberA - numberB; }

public double divide(double numberA, double numberB) { return numberA / numberB; }

public double multiply(double numberA, double numberB) { return numberA * numberB; }

} After that, you can test this simple program by writing the below code in file. org.nipunaupeksha.junit5 → Main.java package org.nipunaupeksha;

public class Main { public static void main(String[] args) {

SimpleCalculator simpleCalculator = new SimpleCalculator();

double resAdd = simpleCalculator.add(5, 10); double resSubtract = simpleCalculator.subtract(15, 10); double resDivide = simpleCalculator.divide(10, 3); double resMultiply = simpleCalculator.multiply(5, 2);

System.out.println("Addition result: " + resAdd); System.out.println("Subtraction result: " + resSubtract); System.out.println("Division result: " + resDivide); System.out.println("Multiplication result: " + resMultiply); } } The output of the above code snippet is shown below. Since we have a small project that is working, let’s start writing tests to validate and improve our code. Part 2 - Writing a Simple Test When writing test cases, it is important to follow proper file structure. The best practice is to follow the same directory structure you follow for the section of the code for the section. Therefore, first, create a package named inside the section. main test org.nipunaupeksha test Next, create a file named, inside that package. SimpleCalculatorTest Rather than creating a new package and file, you can easily do this with IntelliJ IDEA as well. To create a new test file, simply click on the class you want to test on (in our case ) and press in Mac (In Linux and Windows this option can change according to the key bindings(Keymap) you have set on the IntelliJ IDEA). Then it will pop up few options and from those options you can select to create a new test file. SimpleCalculator Option + enter Create Test Now, go to the file, and create your first test by adding the following code. SimpleCalculatorTest package org.nipunaupeksha;

import org.junit.jupiter.api.Test;

public class SimpleCalculatorTest {

@Test void testAdd() { } } You can see that, I have used the annotation in the above code snippet. To show the application, that the method you created is only for testing purposes, you have to annotate it with the annotation. Since, we haven’t written any code inside the method, if we were to run this test, it would pass without any errors. (If you are getting any errors, due to the Java version, fix it in the project settings). @Test @Test testAdd Now, if we were to test any of the code that we wrote in class, we need to bring that object into file. But, the issue is, for every test we need to create a new object. So how can we fix that? SimpleCalculator SimpleCalculatorTest SimpleCalculator Since we need to create a new object every time we run a test method (e.g. , (not implemented yet)) we are making two mistakes if we are going to directly create that object as shown below. SimpleCalculator testAdd testSubtract ... @Test void testAdd(){ SimpleCalculator simpleCalulator = new SimpleCalculator(); ... }

@Test void testAdd(){ SimpleCalculator simpleCalulator = new SimpleCalculator(); ... } ... So how can we avoid that? JUnit gives us an option to run a method every time before a test starts. You can use that option by using the annotation. So what we can do is update our code as shown below, so that, we do not need to create the same object again and again when we write new tests. @BeforeEach package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { } } Similar to we can use the annotation to tear down any of the objects we created or configurations we made. Usually, the method names, and are used for and annotations respectively. @BeforeEach @AfterEach setUp tearDown @BeforeEach @AfterEach Similar to and annotations, you can use and annotations. But make note that these annotations can be used only with static methods. Therefore, whatever configurations or objects you are making are done in a static context. @BeforeEach @AfterEach @BeforeAll @AfterAll Part 3 - JUnit5 Assertions When using JUnit you are dealing with assertions most of the time. Assertions simply mean that you are asserting a condition for the test to pass. Let’s say that the is returning a value that we added to a variable named and we are passing numbers 2,4 to the method. Then the output we should get should be 6. We can assert that the method is working correctly with the assertions that JUnit provides(e.g. ). add(double numberA, double numberB) result add() assertEquals Let’s write an assertion to test whether the output we are getting from the method is correct or not. add() package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { assertEquals(6, simpleCalculator.add(2, 4)); } } As you can see we have used the static method to confirm whether the output we are getting from the method is correct. Now, we can run it by clicking the gutter icon. assertEquals() add() When writing assertions always remember to use the expected value as the first parameter and the code you want to test as the second, actual parameter. Similar to there are quite a few assertions that you can use when using JUnit. You can check all the assertions you can use from . assertEquals here We can also pass an additional argument with assertions to provide us with an error message if the assertion fails. This is useful since, when an assertion is failed it usually gives the error trace and does not give a message of what went wrong. Therefore, adding error messages to assertions can help you save a lot of time. As you can see, since the assertion has failed it gives you a message saying Now we can check the passed parameters and can identify that we have passed 2 and 4 to the method instead of 2 and 3. To increase the performance of the message, if it is an expensive message to build, you can use lambda expressions to make sure the fail message is only built when the assertion has failed. Wrong result returned. add() Part 4 - Grouped Assertions We can also create grouped assertions with JUnit as well. For example, let’s say we need to confirm all the calculation methods in one go we can use grouped assertions as shown below. package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 4), () -> "Wrong result returned."); }

@Test void testCalculations(){ assertAll("Calculations Test", ()-> assertEquals(5, simpleCalculator.add(2,3)), ()-> assertEquals(1, simpleCalculator.subtract(2,1)), ()-> assertEquals(4, simpleCalculator.divide(8,2)), ()-> assertEquals(10, simpleCalculator.multiply(2,5))); } } The first parameter of is the heading for your assertion group, and the respective properties are what you can test as assertions. Now, if we run that test using the gutter icon, we can see that all of them are running correctly. assertAll In addition, we can use fail messages in grouped assertions to find what assertion caused the failure as well. package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 4), () -> "Wrong result returned."); }

@Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5)), "Multiplication failed."); } } Part 5 - Skipping JUnit Tests Let’s say you want to skip some of the tests that you have written but you don’t want to delete those tests. In that case, JUnit offers annotation to skip that test. For example, if we want to disable the method we wrote, we can simply add the annotation for that method. @Disabled testCalculations() @Disabled package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Disabled @Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } Now, if we run all the tests available in class it will only check the method. SimpleCalculatorTest testAdd Similarly, you can disable all the test methods in a certain class by adding the annotation for the class. For example, if we want to disable all the test methods in class we can use the following code snippet. @Disabled SimpleCalculatorTest package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

@Disabled public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } And we can add a message to the annotation as well. @Disabled package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

@Disabled(value = "Testing @Disabled Annotation") public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } Part 6 - Giving Names to Tests When we are writing and testing the tests we can only see the test method name like, or . But if we use more human-friendly names for our tests, it helps other developers to understand the tests we wrote and improve our code quality as well. To do that, we can use annotation. testAdd testCalculations @DisplayName package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@DisplayName("Testing the add() method in SimpleCalculator") @Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Disabled @DisplayName("Testing all the arithmetic operations in SimpleCalculator") @Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } Now, we can see the display names of our tests when we run them. Part 7 - Testing for Expected Exceptions We know that if you can’t divide any number by 0. So we need to alter our code a little bit to throw an when the is 0. Let’s do that first. SimpleCalculator ArithmeticException numberB package org.nipunaupeksha;

public class SimpleCalculator { public double add(double numberA, double numberB) { return numberA + numberB; }

public double subtract(double numberA, double numberB) { return numberA - numberB; }

public double divide(double numberA, double numberB) { if(numberB == 0) throw new ArithmeticException("numberB cannot be zero"); return numberA / numberB; }

public double multiply(double numberA, double numberB) { return numberA * numberB; }

} Now we have altered our code, how can we test that? Testing for expected exceptions in JUnit is quite different from simple assertions since we have to use for that. Let’s create a new test named for this scenario to check whether an is thrown. assertThrows testDivideException ArithmeticException package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@DisplayName("Testing the add() method in SimpleCalculator") @Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Test void testDivideException() { assertThrows(ArithmeticException.class, () -> simpleCalculator.divide(10, 0)); }

@Disabled @DisplayName("Testing all the arithmetic operations in SimpleCalculator") @Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } Now, if we run the test, we can see that it is marked green to indicate the test is successful. Part 8 - JUnit Assumptions JUnit assumptions are conditional statements you write to check whether your assumption on the code is correct or not. Unlike assertions, they don’t fail the test if the expected value is not similar to the actual value. Instead, they will be ignored if the expected value is not similar to the actual value. Let’s check how you can write the assumptions using JUnit. ... @Test void testAddAssumption(){ assumeTrue(simpleCalculator.add(2,4) == 5); } ... Now, you can see that the assumption we made is false since 2+4 is not equal to 5. If we run this, our test will not fail, but it will get ignored. testAddAssumption Assumptions are really important whenever it does not make sense to continue the execution of a given test method — for example, if the test depends on something that does not exist in the current runtime environment. Part 9 - Conditional Test Execution with JUnit We can perform conditional testing with JUnit as well. Assume you have a method, that you need to test on Mac and Windows. You can use conditional testing to do that. Similarly, if you want to test your method with different Java versions, you can do that with conditional testing as well. A few examples of using, conditional testing have been given below. You can find more about conditional testing from . here ... @DisplayName("Testing the add() method in MacOs") @EnabledOnOs(OS.MAC) @Test void testAddOnMacOs(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@DisplayName("Testing the add() method in Windows") @EnabledOnOs(OS.WINDOWS) @Test void testAddOnWindows(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@DisplayName("Testing the add() method in Java 8") @EnabledOnJre(JRE.JAVA_8) @Test void testAddOnJava8(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@DisplayName("Testing the add() method in Java 17") @EnabledOnJre(JRE.JAVA_17) @Test void testAddOnJava17(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); } ... Now, if we run the test class you can see that, it does not run and since I am using MacOS and Java 17 in this project. SimpleCalculatorTest testAddOnWindows testAddOnJava8 In addition to the aforementioned annotations, you can use (e.g. )annotation to conditionally run your tests based on your environment variables. @EnabledIfEnvironmentVariable @EnabledIfEnvironmentVariable(named=”USER”, matches=”nipunaupeksha”) Part 10 - Using AssertJ with JUnit is an alternate asserting library that you can use along with JUnit. In this section, we will look at some of the features of AssertJ that you can use with JUnit. If you need more information on AssertJ you can always use the official to check them out. AssertJ documentation To use AssertJ, we need to add that to the file’s dependency list. pom.xml ... org.assertj assertj-core 3.24.2 test ... Now, let’s try using AssertJ to write a new test case for our method in . subtract() SimpleCalculator import static org.assertj.core.api.Assertions.assertThat; ... @DisplayName("Testing the subtract() method in SimpleCalculator using AssertJ") @Test void testSubtract(){ assertThat(simpleCalculator.subtract(10, 5)).isEqualTo(5); } ... As you can see, with a simple method, it provides several methods that we can chain to use with the assertions. This helps the code to be simpler since we are only importing one static method and we can chain any assertion we need to that method(e.g. , ). assertThat assertThat isEqualTo() isNotEqualTo() Part 11 - Using Hamcrest with JUnit is another library that you can use with JUnit for more versatile assertions. Let’s check how you can use Hamcrest with JUnit by adding it to the file’s dependency list. Hamcrest pom.xml ... org.hamcrest hamcrest-library 2.2 test ... Let’s check the method of with Hamcrest. Since we have to use in Hamcrest as well, comment out the AssertJ imports and the test method, . multiply() SimpleCalculator assertThat() testSubtract() import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; ... @DisplayName("Testing the multiply() method in SimpleCalculator using Hamcrest") @Test void testMultiply() { assertThat(simpleCalculator.multiply(2,5), is(10.0)); } ... Part 12 - JUnit Tags JUnit tags allow you to identify the tests and put those tests into a group. You can define tests at the class or method level. Depending on the test files and methods, you can group them properly with class-level or method-level tags. Let’s use tags to group our tests in the file. SimpleCalculatorTest package org.nipunaupeksha;

import org.junit.jupiter.api.*; import org.junit.jupiter.api.condition.EnabledOnJre; import org.junit.jupiter.api.condition.EnabledOnOs; import org.junit.jupiter.api.condition.JRE; import org.junit.jupiter.api.condition.OS;

//import static org.assertj.core.api.Assertions.assertThat; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assumptions.assumeTrue;

public class SimpleCalculatorTest {

private SimpleCalculator simpleCalculator;

@BeforeEach void setUp() { simpleCalculator = new SimpleCalculator(); }

@Tag("Addition") @DisplayName("Testing the add() method in SimpleCalculator") @Test void testAdd() { // assertEquals(5, simpleCalculator.add(2, 4), "Wrong result returned."); assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Tag("Addition") @DisplayName("Testing the add() method in SimpleCalculator as an assumption ") @Test void testAddAssumption(){ assumeTrue(simpleCalculator.add(2,4) == 5); }

@Tag("Addition") @DisplayName("Testing the add() method in MacOs") @EnabledOnOs(OS.MAC) @Test void testAddOnMacOs(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Tag("Addition") @DisplayName("Testing the add() method in Windows") @EnabledOnOs(OS.WINDOWS) @Test void testAddOnWindows(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Tag("Addition") @DisplayName("Testing the add() method in Java 8") @EnabledOnJre(JRE.JAVA_8) @Test void testAddOnJava8(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

@Tag("Addition") @DisplayName("Testing the add() method in Java 17") @EnabledOnJre(JRE.JAVA_17) @Test void testAddOnJava17(){ assertEquals(5, simpleCalculator.add(2, 3), () -> "Wrong result returned."); }

// @DisplayName("Testing the subtract() method in SimpleCalculator using AssertJ") // @Test // void testSubtract(){ // assertThat(simpleCalculator.subtract(10, 5)).isEqualTo(5); // }

@Tag("Division") @DisplayName("Testing the ArithmeticException when you divide any number by zero") @Test void testDivideException() { assertThrows(ArithmeticException.class, () -> simpleCalculator.divide(10, 0)); }

@Tag("Multiplication") @DisplayName("Testing the multiply() method in SimpleCalculator using Hamcrest") @Test void testMultiply() { assertThat(simpleCalculator.multiply(2,5), is(10.0)); }

@Tag("All") @Disabled @DisplayName("Testing all the arithmetic operations in SimpleCalculator") @Test void testCalculations() { assertAll("Calculations Test", () -> assertEquals(5, simpleCalculator.add(2, 3), "Addition failed."), () -> assertEquals(1, simpleCalculator.subtract(2, 1), "Subtraction failed."), () -> assertEquals(4, simpleCalculator.divide(8, 2), "Division failed."), () -> assertEquals(10, simpleCalculator.multiply(2, 5), "Multiplication failed.")); } } So, now if we want to run only the tests, we can configure it in the IntelliJ IDEA by going to the top toolbar and clicking on the . Addition Edit Configurations Click on the + symbol to add a new JUnit configuration and give it a name. Then select the resource to and give the tag name there (in our case ). Tags Addition Now, if you run that configuration, only the tests marked with will get executed. @Tag(“Addition”) Part 13 - Nested Tests You can write nested tests by defining another class within the test class. Let’s create a new file named, to test the nested tests. SimpleCalculatorNestedTest package org.nipunaupeksha;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

@DisplayName("SimpleCalculator") public class SimpleCalculatorNestedTest { private SimpleCalculator simpleCalculator;

@BeforeEach void setUp(){ simpleCalculator = new SimpleCalculator(); }

@DisplayName("Addition") @Nested class NestedAddition{

@DisplayName("Check adding two numbers is correct.") @Test void testAddTwoNumbers(){ assertEquals(10, simpleCalculator.add(8,2)); } }

@DisplayName("Division") @Nested class NestedDivision{

@DisplayName("Check dividing two numbers is correct.") @Test void testAddTwoNumbers(){ assertEquals(4, simpleCalculator.divide(8,2)); } } } Now, if you run this, you can see, the test outputs are grouped due to the usage of annotation. @Nested Part 14 - JUnit Test Interfaces Since we have two test files named and , we can use annotation to group them into something like ( ). Also, we can use test interfaces for that as well. Let’s create a new interface, with the tag and use them in the aforementioned classes, so that they can be used with the tag, . SimpleCalculatorTest SimpleCalculatorNestedTest @Tag SimpleCalculator @Tag(“SimpleCalculator”) ISimpleCalculator SimpleCalculator SimpleCalculator package org.nipunaupeksha;

import org.junit.jupiter.api.Tag;

@Tag("SimpleCalculator") public interface ISimpleCalculator { } package org.nipunaupeksha;

import org.junit.jupiter.api.*; import org.junit.jupiter.api.condition.EnabledOnJre; import org.junit.jupiter.api.condition.EnabledOnOs; import org.junit.jupiter.api.condition.JRE; import org.junit.jupiter.api.condition.OS;

//import static org.assertj.core.api.Assertions.assertThat; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assumptions.assumeTrue;

public class SimpleCalculatorTest implements ISimpleCalculator{