Learn How to write tests by using JUnit

Testing is a very important process in the development cycle of an application. It is necessary to find out bugs which may be present in any program. Testing is largely the main process which ensures that a software developer or company is actually delivering a quality product to their client. Now, there are many frameworks used mainly for testing units of code. In this article, we will explore JUnit as a testing framework and how it can be implemented in a Java application.

What is JUnit?
JUnit is actually a very powerful testing framework meant for Java applications. JUnit puts an emphasis on testing before implementing the code.
For this, the first task is to set up the testing environment for the code. After that, the coding part has to be implemented in the application. As every part of the program is tested and coded separately, the application developed runs quite efficiently. Also, debugging a program is much easier as every part of the code is separately checked for the presence of bugs.
The JUnit framework is a part of a family of Java frameworks known as the xUnit. All the frameworks present in the xUnit are used for unit testing in Java.

Background
As already stated above, JUnit primarily happens to be a testing framework that’s meant for unit testing of code. It is also basically a framework that allows for test-driven development, i.e. the repetition of short development cycles, with the requirements being turned into exclusive test cases.
JUnit was said to have been first developed in 1997. Kent Beck, Erich Gamma, David Saff and Mike Clark are credited with being the creators of this testing framework. The framework is a cross-platform framework that is written in Java and falls under the Eclipse Public License. It also happens to be one of the most commonly used frameworks for unit testing.

Why JUnit is important?
Unit testing is perhaps one of the most important ways that should be implemented to deliver quality software. It is basically meant to test code in way that allows the testing of each and every unit separately.
As for JUnit, it is pretty much like every other testing framework, one that assists in finding bugs in code snippets. A unit testing framework ensures that each component of the complete software works optimally, which makes it very important in the development cycle of any software. However, it does not test the connection between different components, which is the case with integration testing frameworks.

What are the features?
There are many features of JUnit that we shall take a look at.

• Firstly, it is a completely open-source project, so it can be used quite easily.
• It uses Annotations which helps in the identifying the methods to be used in testing.
• JUnit offers tests runners which are useful for running tests.
• With JUnit, one can also make use of Assertions, in order to test expected results.
• JUnit is very simple and allows very fast and flexible testing.
• The tests running on JUnit can be scheduled to run automatically and then it checks and offers feedback on the tests too.
• Tests in this framework can be converted into test suites that contain numerous test cases. It is also applicable for other test suites.
• A green bar shows the progress of the test, which turns red on a failure.

Pros and cons of using JUnit
1. What are the pros?
JUnit is considered as one of the best testing frameworks for Java; so naturally, it has many pros. JUnit makes software testing very flexible. For example, if you make any kind of modification to a part of the code in the program, you can actually test if that code will run properly without even running the whole code. Also, you can create your own unit test case suite, in order to easily test similar programs.
The unit tests made in JUnit are very light and can be adapted according to the code quite easily. Another thing is that it is extremely easy to use, even for beginners.
2. What are the cons?
Every testing framework has some problems. The main problem in JUnit is the fact that it tests code by calling some methods and then it compares the outputs with those which should have come. While this may work perfectly with methods that return the outputs only, not all methods work in this way. For testing, if the methods actually carry out the output, you’ll have to capture them, and this is a really long piece of programming process.
Another major con of JUnit is that for testing using methods that change the state of the object being tested, the code has to be adapted according to that state. Testing GUI code in units can be really hard. So, it is a good idea to write tests yourself for validating the objects.

Installation and configuration
As we have already discussed that JUnit is a testing framework for Java based applications, so JDK must be installed first. Let us check the configuration steps one by one.
Step 1: Download and install Java Software Development Kit (SDK). The JDK version should be 1.5 and above. It can be downloaded from the following link.
JDK down load link: http://www.oracle.com/technetwork/java/javase/downloads/index.html
Step 2: After download and installation, set up JAVA_HOME environment variable pointing to jdk version in your local file system.
For example, JAVA_HOME = C:\Program Files\Java\jdk1.6.0_38
Step 3: Download JUnit and set up the environment. Latest version can be downloaded from the following link.
JUnit download link: https://github.com/junit-team/junit4/wiki/Download-and-Install
After this, set up JUNIT_HOME environment variable and point to the JUnit jar in your local system.
For example JUNIT_HOME = C:\JUnit
Now the environment setup is complete and we can run a sample Java application to test it.

Sample application
In this sample example, we will create a test unit class and a test runner class. Test runner class will check the test unit class and produce an output in Boolean value (true/false).
Listing 1: Test unit class sample
// This is the unit test class to be tested

import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class JunitTest {
   @Test
   public void testJunit() {
      String strtst= "Testing with JUnit is OK";
      assertEquals("Testing with JUnit is OK",strtst);
   }
}

Listing 1: Test runner class to check the output
//This is the test runner class

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class JUnitTstRunner {
   public static void main(String[] args) {
      Result tstresult = JUnitCore.runClasses(JunitTest.class);
      for (Failure tstfailure : tstresult.getFailures()) {
         //Printing output
        System.out.println(tstfailure.toString());
      }
     //Printing output
      System.out.println(tstresult.wasSuccessful());
   }
}

To test the result, first compile both the classes as shown below
C:\JUNIT_TEST_WORKSPACE>javac JunitTest .java  
C:\JUNIT_TEST_WORKSPACE>javac JUnitTstRunner.java
After this, execute the test runner class as shown below
C:\JUNIT_TEST_WORKSPACE>java  JUnitTstRunner
The output will be displayed on the console as shown below.
true

Conclusion
JUnit is a very powerful testing framework belonging to the xUnit family of unit testing frameworks developed for Java. It is really very useful for those developers using Java who want their program to be completely devoid of any kind of bug. JUnit is a unit testing framework, so it allows the testing of every snippet of code before even actually implementing it to the main application. This allows the developer to easily search for and resolve any kind of bugs, even if it is hidden deep inside the coding.

Nowadays, more and more developers are using JUnit, not only for the ease of use but also because it does not produce any heavy strain on the system on which the code is being tested. Thus, it is one of the most popular unit testing frameworks for Java app development.