JUnit is a regression testing framework which is used for performing Unit Testing of Java code.

It is an open-source software managed by JUnit.org community.

JUnit = Java + Unit Testing

The important features of JUnit are:

• It is an open-source framework.
• It provides various annotations to identify test methods.
• It provides test runners for running tests.
• It provides assertions to test the expected results.
• It shows test progress in a bar. If the test goes fine, then it shows green and when a test fails, it turns to red.
• It can be organized into test suites that contain test cases and other test suites as well.

JUnit framework provides the following features:

• Fixtures
• Test Suites
• Test Runners JUnit Classes

JUnit classes are important classes that are used in writing and testing JUnit programs.

Some of the important JUnit classes are:

• Assert: Contains a set of Assert methods.
• TestCase: Contains a test case that defines the fixture to run multiple tests.
• TestResult: Contains a method that collects the results after execution of the test case.
• TestSuite: It is a composition of JUnit tests.

A test fixture in JUnit is defined as a fixed state of some set of objects which are used as a baseline for running tests.

The main objective of a test fixture is to ensure that there is some known and fixed environment in which tests are run so that results are repeatable.

It basically includes the following methods:

• setUp() method which runs before every test methods.
• tearDown() method which runs after every test methods.

JUnit annotations are like meta-tags that can be added to our code, and we can apply them to methods or in class.

Annotations are very useful in JUnit as they give the information about test methods that which methods are going to run before test methods or which methods are going to run after test methods. It also gives the information that which method or class will be ignored during execution.

The important JUnit annotations are as follows:

• @Test: The Test annotation tells that this is the test method which will run first, unless specified.
• @BeforeClass: The method with @BeforeClass annotation specifies that it should be run once before any of the Test methods in the class.
• @Before: The method with @Before annotation specifies that it should be run before each test method.
• @After: The method with @After annotation specifies that it should be run after the test method.
• @AfterClass: This method with @AfterClass annotation specifies that it should be run after all tests have finished. This can be used for performing clean-up activities.

@Ignore annotation is used to ignore that particular tests or group of tests so that build failure can be skipped.

@Ignore annotation is very useful when there are cases when we can’t fix a code that is failing but still, we want that method to be around so that it does not get forgotten, and we can fix them later.

Also, it is very easy to identify all @Ignore annotation rather than finding the comment out test cases.

Parameterized Tests allow developers to pass parameters into their test classes and hence allowing him to run the same test, again and again, using different values.

Annotations used for Parameterization are

• @RunWith(Parameterized.Class) – To make a class parameterized.
• @Parameters – Parameterized class must have a static method with a @Parameter annotation that returns a collection of the array as a test data set.

Ideally, we should not change the return type of JUnit test from void to some other type. All the methods of JUnit tests should have a void return type.

If we change the return type from void to some other type, then the test method would not be considered as a test method and would be ignored during the execution of tests.

JUnit can be easily integrated with the following tools:

• Eclipse
• Ant
• Maven

Following are some of the JUnit extensions:

• Cactus
• JWebUnit
• XMLUnit
• MockObject

Cactus is a testing framework that is used for unit testing server-side java code such as Servlets, EJBs and Tag Libs.

The intent of Cactus is to minimize the cost of writing tests for server-side code. It uses JUnit internally and extend it. Cactus implements an in-container strategy, which means that the all the tests are executed inside the container.

The components of cactus are:

• Cactus framework is the core of Cactus. It provides the API to write Cactus tests.
• Cactus Integration Modules are other components, and they are front ends and frameworks that provide the easy way of using the Cactus framework like Ant Scripts, Eclipse plugin or Maven plugin.

Web Unit is a Java-based testing framework to test web applications. It wraps existing testing frameworks like Selenium and HtmlUnit with a simple, unified testing interface and that allows us to quickly test the correctness of web applications.

The various advantages of JWebUnit are as follows:

• It provides a high-level Java API which is used for navigating a web-application with a set of assertions to verify the correctness of the application.
• This API includes form entry and submission, navigation via the link, validation of table contents and other typical business web application features.
• The ready to use assertions and simple navigation is helpful for more rapid test creation.

XMLUnit is used for providing a single JUnit extension class, XMLTestCase and a set of supporting classes.

Supporting classes in XMLUnit allow assertions to be made about:

• Differences between 2 pieces of XML through Diff and DetailedDiff classes.
• Validation of a piece of XML through Validator class.
• The result of transforming a piece of XML using XSLT through transform class.
• The evaluation of XPath expression on a piece of XML through XPath engine interface.
• Individual nodes in a piece of XML that are exposed by Dom traversal through NodeTest class.

Reporting multiple failures in a single test implies that the test is doing too much, and it is too big a unit test.

So, JUnit is designed in such a way that it works best with a number of small tests.

It executes each test within a separate instance of test class and reports failure on each test.

To run JUnit from the command window, we have to follow the following steps:

• Set the ClassPath: set CLASSPATH = %JUNIT_HOME%\junit.jar
• Invoke JUnit runner: java org.junit.runner.JUnitCore

The different methods of Exception handling in JUnit are as follows:

• Try catch statement
• With @Test annotation
• With catch exception library
• With JUnit rule
• With custom annotation

The various best practices to be followed while writing a unit test in JUnit are as follows:

• A well-written test case is the one that has a known input and expected output, which is computed before the execution of the test.
• A known input should always test a precondition, and the expected output should always verify a post-condition.
• It is always recommended to have at least 2 unit test cases for each requirement, one of them is positive test and the other one is for negative test.
• If any requirement have sub-requirements, then it should also have at least 2 unit test cases as positive and negative tests.

JUnitTestNGThe naming convention for JUnit annotation is a bit complicated, like “Before”, “After” and “Expected”. The naming convention of TestNG is easier to understand like “BeforMethod”, “AfterMethod”, etc. Grouping of test cases is not available in JUnit. Grouping of test cases is possible in TestNG.JUnit framework does not have the “Dependency Test” feature.TestNG use “dependsOnMethods” to implement dependency testing. JUnit does not support parallel execution of Selenium test cases. Parallel execution of Selenium test case is possible in TestNG.JUnit cannot re-run the failed tests.TestNG can re-run the failed tests.