To write a test case, follow these steps:
Define a subclass of TestCase.
Override the setUp() method to initialize object(s) under test.
Optionally override the tearDown() method to release object(s) under test.
Define one or more public testXYZ() methods that exercise the object(s) under test and assert expected results.
This is the most popular Junit Interview Questions asked in an interview. WebUnit is also a Java-based testing framework to test web applications. It wraps around existing testing frameworks to allow quick testing of web applications and comes with a unified, simple testing interface.
To verify the correctness of an application, JWebUnit provides a high-level Java API to test a web application along with a set of assertions. This includes navigation through links and forms entry and submission. It also involves validation of table contents and other usual business web application features.The easy navigation methods that come with ready-to-use assertions allow for more rapid test creation than using Junit or HtmlUnit only. And if switching from HtmlUnit to other plugins such as Selenium are needed there should be no need to rewrite tests.
Reporting multiple failures in a single test is generally a sign that the test does too much and it is too big a unit test. JUnit is designed to work best with a number of small tests. It executes each test within a separate instance of the test class. It reports failure on each test.
Installation steps for JUnit :
Download the latest version of JUnit, referred to below as junit.zip.
Unzip the junit.zip distribution file to a directory referred to as %JUNIT_HOME%.
Add JUnit to the classpath −
set CLASSPATH=%CLASSPATH%;%JUNIT_HOME%junit.jar
Test the installation by running the sample tests distributed with JUnit (sample tests are located in the installation directory directly, not the junit.jar file).
Then simply type −
java org.junit.runner.JUnitCore org.junit.tests.AllTests
All the tests should pass with an “OK†message. If the tests don’t pass, verify that junit.jar is in the CLASSPATH.
Yes, It’s possible to pass command line arguments to a test execution –
You should use this command:
-D JVM command-line options
Ideally you should not do this. All the JUnit test methods should have a void return type. If you change the return type then the test method would not be considered as a test method and would be ignored during execution of tests.
No there is no time constraint. A JUnit test needs to run whenever there is a change in the source code. This ensures that the new change passes through all the tests.
@Rule annotation is used for creating objects, which later can be used in test methods.
Parameterized tests are possible in JUnit and they provides us the liberty of passing parameters into the test classes.
@RunWith(Parameterized.class) – For making a class parametrized.
@Parameters – Parameterized class must have a static method for generating and returning a collection of array, this method should be marked with @Parameters annotation.
This class is mainly responsible for executing tests. The org.junit.runner.JUnitCore class has a runClasses() method, which allows us to run one or more test classes. As a output we get a Result (org.junit.runner.Result) object, which we use to filter out the test information.
The convention you follow should have every information required by the method name in a structured manner. Unit tests name should act like the documentation giving a clear idea of what functionality is tested. There are various techniques that could be used to name unit tests. Some of them are the following: Given… When… Then… Should… etc.
Mocking is a feature where an object mimics like a real object. Stubbing are codes that are responsible for taking place of another component.
There are various different Java mocking framework such as Mockito, EasyMock etc.
As code cyclomatic complexity is determined based on number of decision points within the code and hence execution paths, higher cyclomatic complexity makes it difficult to attain achieve test/code coverage.
A test fixture in unit testing is used to provide a well-known and fixed environment in which the test can be run. A text fixture could be set up or mock objects or loading specific data from the database for testing. JUnit provides @Before and @BeforeClass annotation for creating text fixtures and @After and @Afterclass for doing cleanup.
The test runner holds the references for the duration of the test. In the case of an extended test having many test instances, the garbage may not be collected until the end of the test run. We can use the tearDown() to collect the garbage before the test run completes. In this method, we explicitly set an object to null.
If you use System.out.printIn() to debug your code, it would benefit in the long run. Every time the program is run, it would result in manual scanning of the entire output to ensure that the code is operating correctly. So, it would require relatively less time to code JUnit methods and perform testing on class files.
A test fixture in unit testing is used to provide a well-known and fixed environment in which the test can be run. A text fixture could be set up or mock objects or loading specific data from the database for testing. JUnit provides @Before and @BeforeClass annotation for creating text fixtures and @After and @Afterclass for doing cleanup.
(i) Fixtures are used as the baseline for executing tests, establishing the repeatability of the results. A test fixture comprises a fixed state of a set of objects. Methods include:
setUp(): It runs before a test invocation.
tearDown(): It runs after a test method.
(ii) Test Runner: It executes the test cases.
(iii) JUnit Classes: They contain methods to be used in writing and testing JUnits.
(iv) Test Suite is a bundle or collection of unit test cases to be run together. You can run a suite test in JUnit with either @Suite or the @RunWith annotation.
In this situation, the compilation would pass, but the execution will fail. This would occur because all JUnit test methods are designed to return “void.â€
In the protected method, test class and target class are declared in the same package. However, in the private method, there is no direct way of testing. Either you have to change your method to ‘protected’ or do the testing manually.
A test case is a code that is written to establish the logic of a program. In JUnit, it is unnecessary to write a test case for every logic but only for those that can be reasonably broken.
A unit test case would comprise a collection of input data and expected output. The org.junit package contains several classes and interfaces to help you in unit testing, such as Assert, Test, Before, After, etc.
Manual testing is executed without test scripts and requires dedicated human effort for the various steps involved. On the other hand, automated testing can be done without human assistance using technology tools and software programs. Test automating is cheaper and less time-consuming than manual testing. Also, manual testing is less reliable as it cannot be programmed.
It allows you to create JUnit rules, which can be used to add or redefine the behavior of each test method in a test class. You can write your own rules using @Rule annotation.
Well, since private methods are not accessible outside the class they are declared, it's not possible to test them using JUnit directly, but you can use Reflection to make them accessible by calling setAccessible(true) before testing. Another way to test private methods is via public methods, which uses them. In general, testing the private method is also an indication that those methods should be moved into another class to promote reusability.
Since protected methods are accessible to everyone inside the same package they are declared, you can put your JUnit test class also on the same package to test them. But, don't mix your test code with real code, instead, put them on a different source tree. You can use a Maven-like structure to organize your test and source classes in different folders.
When a JUnit method throws an uncaught exception, which is also not declared as expected using the @Test(expected) parameter then the JUnit test will fail, but if it's declared and expected then the JUnit test will pass. If the method under test throws an exception that is caught by you inside the JUnit test method then nothing will happen and the test will be passed
The @RunWith annotation allows you to run your JUnit test with another, custom JUnit Runner. For example, you can do some parameterized testing in JUnit by using @RunWith(Parameterized. class), this Runner is required for implementing parameterized tests in JUnit.
Some of the popular third-party implementations of JUnit runners include SpringJUnit4ClassRunner and MockitoJUnitRunner, which you can use with @RunWith annotation to test Spring beans and Mockito library.
Here are some of the best practices you can follow to make your code more testable :
1) Use interface instead of concrete class, this allows the tester to replace actual class with Mock or Stub for testing purposes.
2) Use Dependency injection, it makes it easy to test individual parts and supply dependency from test configuration. You can create an actual object which is dependent on the Mock and stub for testing. This also allows you to test a class even if its dependency is not yet coded.
3) Avoid static methods, they are difficult to test as they cannot be called polymorhpically.
Here is the following list of the execution procedures which would help to analyze the problem. It is as follows:
1. In the first step, you need to use the annotation in the form of @before class
2. Secondly, make sure that you use the annotation @after class
3. Subsequently, before executing the test class, make sure that you use @before performs
4. Lastly, use @before so that the application development process is smooth and is hassle free
In version 4 of JUnit, there is a new feature known as Parameterized Tests. These tests usually allow the developer to run the same amount of tests over and again. In this manner, the suitability of using various values increases considerably.
Here is the list of advantages of using this kind of annotation
1. It is important to note that one can easily find @ignore annotations with relatively much ease that lies inside the source code. On the other hand, the unannotated and uncommented tests are complicated to find.
2. Moreover, one may come across various situations where one cannot fix a code. However, if you still want that source method to be taken into account, @ignore annotation plays a crucial role in that.
It is interesting to note that saying multiple shortcomings in one attempt signifies that the test is of a larger size. This is the reason that JUnit is designed in such a manner that it usually runs on a smaller number of tests. Quite interestingly, it is capable of executing each assessment within the boundaries of a separate analysis. Moreover, it is also able to report the failures on each attempt of the tests.
As code cyclomatic complexity is determined based on number of decision points within the code and hence execution paths, higher cyclomatic complexity makes it difficult to attain achieve test/code coverage.
The advantages of writing unit tests include Design testability, Code testability and Code maintainability as good unit tests enforces Object Oriented principles such as Single Responsibility etc. which enables people to avoid code smells such as long classes, long methods, large conditionals etc.
Well, from JUnit 4 onwards you can use @Ignore annotation to instruct JUnit runtime to not execute any particular test or disable any test as shown in this JUnit ignore example. You can also use this method for annotating unimplemented test methods. Btw, you should use @Ignore only temporarily and remove it as soon as possible by either implementing the test methods or removing it if not required.
A test fixture is also known as a regulated state of objects that can be used as a platform for running the tests. The primary purpose is to make sure that there is a known climate in which the development tests can be run. Various examples can be cited in this context. They are as follows:
1. Copying the fixed known set of files
2. Preparing the input data and the creation of mock and fake objects
3. Assessing a database with fixed and known sets of data
It is also essential for you to note that if a group of tests shares the same fittings, one needs to write a different setup code. On the other hand, if the group of assessments is in need of a different test fixture, one can write the code alongside the test procedure. In this manner, one can create the best accessory related to a test.
Test Suite usually refers to the principle of compiling a variety of unit test cases to run it concurrently. In this context, it is interesting to note that in JUnit, both Run With and Suite comments are being used to avail maximum benefits.
They are methods from JUnit 3.X which is replaced by @Before and @After annotated method. They are used for setting up resources before the test method and for doing clean-up after-test methods.
JUnit creates a separate instance of the test class for calling test methods. For example, if your test class contains 5 tets then JUnit will create 5 instances of the test class for executing those test methods. That's why constructor is called before executing @Test methods. In JUnit 3.X, It used to first create instances and then call the methods but in JUnit 4.1, it first creates an instance and then calls them the method and then goes on to create the second method. This way, it keeps one test isolated from the other.
A fixture is also known as a constant state of a collection of objects that can be used for the execution of tests. The main aim of using a test fixture lies in the fact that there should be a familiar and fixed environment. Moreover, these tests are run so that the results are repeatable. It comprises of the following procedures.
1. The setup method which runs every test
2. The teardown procedure which runs after the execution of a particular test.
The JUnit test framework is associated with the providence of these critical features. They are as follows:
1. Test Suites
2. JUnit Classes
3. Fixtures
4. Test Runners
Mocking is a feature where an object mimics like a real object. Stubbing are codes that are responsible for taking place of another component.
There are various different Java mocking framework such as Mockito, EasyMock etc.
As code cyclomatic complexity is determined based on number of decision points within the code and hence execution paths, higher cyclomatic complexity makes it difficult to attain achieve test/code coverage.
The simplest way to write a JUnit test case is:
a) Determine a subclass of TestCase
b) To initialize object(s) under test, override the setup() method
c) To release object(s) under test override the teardown() method
Determine one or more public test XYZ() methods that exercise the objects under test and assert expected results.
Unit Test Case is a part of the code that ensures that another part of the code (method) behaves as expected. For each requirement, there must be at least two test cases one negative test and one positive test.
The test runner is used to execute the test cases.
@Test: This is the test method to run first unless otherwise specified.
@BeforeClass: This is run once before any of the other test methods present in the class.
@Before: This is run before @Test.
@After: As the name suggests, this is run after the @Test.
@AfterClass: This is run one after all of the tests in the class have been run.
@Before is called per test method while @BeforeClass is called per-test-class level. Also, static methods are annotated with @BeforeClass and you can use them to initialize shared resources e.g. which should be shared by every instance of JUnit class like Database connection.
@Before and @After annotation is used for setup and cleanup jobs. They are actually a replacement of the setUp() and tearDown() method of JUnit 3.X. Remember, a method annotated with @Before will be called before calling a test method and @After will be called after executing the test method.
The main difference between JUnit 3 and JUnit 4 is annotation. Earlier you need to start your method name as testXXX() but from JUnit 4.0 onwards you can use @Test annotation, which removes this dependency to start your Junit test methods as a test.
JUnit is a unit testing framework for the Java application. It allows you to unit test your code at the method level. You can also use JUnit for test-driven development e.g. first writing test and then writing actual code. Most of the Java IDE like Eclipse, Netbeans and IntelliJ Idea provides out-of-box JUnit integration for TDD. Even build tools like Maven, Ant, and Gradle can run the JUnit test at compile and built time.