JUnit Questions

1) What is JUnit, and why is it important for unit testing?

JUnit is a popular testing framework for Java that simplifies the process of writing and running unit
tests. It allows developers to create test cases as simple methods annotated with @Test, making it
easy to check if specific parts of the code work as expected. JUnit is important because it promotes
test-driven development, helps catch bugs early, and ensures that code changes don’t break existing
functionality, ultimately improving software quality and reliability.

2) Explain the difference between @Before and @BeforeClass. How are they used?

In JUnit, @Before and @BeforeClass are annotations used to set up conditions before tests run.
@Before is executed before each test method, allowing you to prepare the environment for
individual tests. In contrast, @BeforeClass runs once before any test methods in the class, typically
for time-consuming setup tasks that are common to all tests, like initializing static resources. Using
these annotations helps keep your test code organized and efficient.

3) How do you test expected exceptions in JUnit?

To test expected exceptions in JUnit, you can use the @Test annotation with the expected parameter.
For example, you would write @Test(expected = IllegalArgumentException.class) above your test
method to indicate that this test should pass if an IllegalArgumentException is thrown. Alternatively,
you can use the assertThrows method in JUnit 5, which allows you to assert that a specific exception
is thrown during execution of a block of code, providing more flexibility in testing exception handling.

4) What is the difference between assertEquals, assertTrue, and assertSame in JUnit?

In JUnit, assertEquals, assertTrue, and assertSame are used to verify conditions in tests.
assertEquals(expected, actual) checks if two values are equal, often used for comparing objects or
primitive values. assertTrue(condition) verifies that a given condition is true, helping to check
boolean expressions. assertSame(expected, actual) checks if two references point to the same object
in memory, ensuring that they are identical instances. Each method serves a specific purpose for
validating test results.

5) What are parameterized tests in JUnit, and how do they work?

Parameterized tests in JUnit allow you to run the same test multiple times with different input
values. This is useful for checking how a method behaves with various data. You define a test class
with the @RunWith(Parameterized.class) annotation, then provide a method annotated with
@Parameters that returns a collection of test data. Each set of parameters is passed to the test
method, enabling efficient testing of multiple scenarios with less code duplication.

GenZ Career on YouTube

Subscribe for Interview Preparation
6) What is a test suite in JUnit, and how do you create it?

A test suite in JUnit is a collection of test classes that can be run together, allowing you to organize
and execute multiple tests as a group. To create a test suite, use the @Suite annotation along with
the @RunWith(Suite.class) annotation on a class. Then, specify the test classes to include within the
@Suite.SuiteClasses annotation. This structure helps streamline testing and ensures that related
tests are executed together for comprehensive validation.

7) How do you handle timeouts in JUnit?

To handle timeouts in JUnit, you can use the timeout parameter in the @Test annotation. For
example, @Test(timeout = 1000) specifies that the test must complete within 1000 milliseconds (1
second). If the test takes longer, JUnit will mark it as failed. This is useful for ensuring that tests don't
hang indefinitely, helping to maintain efficient test execution and prompt feedback during the
development process.

8) How do you structure a test case in JUnit?

To structure a test case in JUnit, follow a clear pattern known as "Arrange, Act, Assert." First, Arrange
by setting up the necessary objects and inputs required for the test. Next, Act by invoking the
method or functionality being tested. Finally, Assert by verifying the expected outcomes using
assertions like assertEquals or assertTrue. This structured approach keeps tests organized and easy to
understand, improving both readability and maintainability.

9) What is the purpose of the @Test annotation?

The @Test annotation is used in programming to mark a method as a test case in a Java application.
This is part of a practice called unit testing, where developers test small parts of an application to
make sure they work correctly. When you add @Test above a method, it tells the system that this
particular method should be run as a test. This helps in automatically checking if your code behaves
as expected without having to run the entire application.

10) How do you mock a static method in JUnit? Is it possible without external libraries?

In JUnit, mocking a static method directly is not possible without using external libraries. JUnit itself
does not provide built-in support for this. However, you can use external libraries like Mockito, which
has a feature from version 3.4.0 onwards that supports mocking static methods. This involves using
the mockStatic method of Mockito, which allows you to create a mock behavior for any static
method within a given scope of a test.

11) Can you explain how @RunWith and @Rule work in JUnit?

In JUnit, @RunWith and @Rule are annotations used to enhance how tests are run. @RunWith
allows you to specify a custom runner that changes the behavior of how your test classes are
executed. For example, it can be used to run tests with special configurations or with a different

GenZ Career on YouTube

Subscribe for Interview Preparation
testing framework. On the other hand, @Rule applies specific functionality to every test method in a
class, like repeating tests or handling exceptions in a standard way.

12) Tricky: How would you test private methods in JUnit? Should you test them directly?

In JUnit, testing private methods directly isn't recommended because it goes against the principles of
testing only the public interface of a class. Instead, you should test private methods indirectly by
calling the public methods that use them. This approach tests the private functionality as part of the
overall behavior of the class, ensuring that all parts work together correctly. If direct access is
necessary, consider the design of your class, as it might need refactoring.

13) Tricky: How do you write a test for a method with database calls in JUnit without hitting the
actual database?

To test a method that makes database calls in JUnit without hitting the actual database, you use a
concept called mocking. By using libraries like Mockito, you can create a mock version of the
database access object. This mock can be programmed to return specific results when methods are
called, allowing you to test how your method behaves with different data scenarios without needing
to connect to a real database. This ensures your tests are fast and not dependent on database
availability.

14) Tricky: How does JUnit handle concurrency when running multiple test methods in parallel?

JUnit handles concurrency by allowing multiple test methods to run in parallel, which can speed up
the overall test execution time. This is done using configurations that specify how many threads
should be used for running tests. However, when tests are run in parallel, it’s important to ensure
that they do not depend on shared resources or affect each other’s state, which could lead to
unpredictable test results. Proper use of synchronization or separate resource instances helps
manage these issues.

15) What are some best practices for writing unit tests using JUnit?

When writing unit tests with JUnit, it's best to keep tests simple and focused on one functionality at a
time. Ensure each test is independent to avoid interference with others. Name your test methods
clearly to reflect what they test. Use assertions to check expected results, and handle setup and
teardown tasks with @Before and @After annotations. Regularly refactor tests to improve clarity and
maintainability, just as you would with production code.

Mockito Questions

1) What is Mockito, and why is it used in unit testing?

GenZ Career on YouTube

Subscribe for Interview Preparation
Mockito is a popular Java library used in unit testing to create mock objects. It is used to simulate the
behavior of complex, real objects in a controlled way. Mockito allows you to set up expectations,
specify the behavior of mocks, and verify that certain operations were performed. This is particularly
useful when you need to test parts of your code in isolation from external systems like databases or
other services, ensuring tests are fast and reliable.

2) How do you mock an object in Mockito?

To mock an object in Mockito, you first need to use the mock() method, specifying the class of the
object you want to mock. This creates a simulated version of that class, which doesn't perform any of
the actual operations of the real object. You can then configure this mock to return specific values or
throw exceptions when its methods are called, allowing you to control its behavior in tests. This helps
in testing other parts of your code that interact with this object.

3) What is the purpose of the @Mock and @InjectMocks annotations?

The @Mock annotation in Mockito is used to create and automatically manage mock objects within a
test class, replacing manual creation using the mock() method. The @InjectMocks annotation
complements this by automatically injecting these mock objects into the fields of another class being
tested. This is especially useful when the class under test has multiple dependencies, allowing you to
focus on the behavior of the class itself while Mockito handles the setup of its dependencies.

4) How do you use when and thenReturn in Mockito?

In Mockito, when and thenReturn are used together to specify the behavior of mock objects during a
test. You use when to define the condition under which a specific method is called on the mock.
Following when, you use thenReturn to define the response that should be returned by the mock
when that condition is met. This setup helps in creating predictable test scenarios where you control
how mocks react to method calls.

5) What is the difference between mock() and spy() in Mockito?

In Mockito, mock() and spy() are used to create fake objects, but they behave differently. Using
mock(), you create a completely simulated object where all methods do nothing unless explicitly
stubbed. In contrast, spy() creates a partial mock that wraps a real object, allowing all methods to
retain their original behavior unless specifically overridden. spy() is useful when you want to alter or
monitor specific behaviors of an object while keeping the rest unchanged.

6) How do you mock a method that returns void in Mockito?

To mock a method that returns void in Mockito, you use the doNothing() method. First, you specify
the method on your mock object with doNothing() and then chain it with when() to set the condition
under which the method should do nothing. This is useful for methods that perform actions like

GenZ Career on YouTube

Subscribe for Interview Preparation
sending emails or logging, where you want to ensure these actions are skipped during testing,
allowing you to focus on other aspects of your code’s behavior.

7) What are the use cases for doReturn(), doThrow(), and doAnswer() in Mockito?

In Mockito, doReturn(), doThrow(), and doAnswer() are methods used to specify behaviors of mock
objects in different scenarios:

1. doReturn() - Used to make a method return a specific value when called.

2. doThrow() - Used to make a method throw a specified exception, useful for testing error
handling.

3. doAnswer() - Provides more complex behavior than returning a value or throwing an

exception, like simulating calculations or modifying an argument passed to the method. This
flexibility is useful for tests that require more detailed interactions with the mock.

8) How do you verify the behavior of a mock object in Mockito?

In Mockito, verifying the behavior of a mock object is done using the verify() method. This method
checks that certain interactions with the mock occurred as expected. For instance, you can verify that
a method was called a specific number of times, or with certain arguments. This is crucial for
ensuring that your code interacts with dependencies correctly. For example, you might verify that a
sendEmail method on a mock MailSender was called once with a particular message.

9) How do you mock an exception using Mockito?

To mock an exception in Mockito, you can use the when() method combined with thenThrow(). First,
define the condition under which the method of the mock object is called. Then, specify the
exception you want the method to throw when that condition is met. This technique is particularly
useful for testing how your code handles errors. For example, you can simulate a network error by
having a data retrieval method throw an IOException.

10) How does ArgumentCaptor work in Mockito? Can you give an example?

In Mockito, an ArgumentCaptor is used to capture arguments passed to methods during testing,

allowing you to verify the values at runtime. This is particularly useful when you want to check the
properties of objects passed to methods without explicitly accessing them. For example, if you have
a method that adds a user to a database, you can use an ArgumentCaptor to capture the user object
passed to the method and assert that its fields are set correctly.

11) Tricky: How do you mock static methods in Mockito?

To mock static methods in Mockito, you need to use the Mockito extension called Mockito-inline.
First, enable static method mocking by using try (MockedStatic<YourClass> mocked =
Mockito.mockStatic(YourClass.class)). Inside this block, you can specify how the static methods of

GenZ Career on YouTube

Subscribe for Interview Preparation
YourClass should behave using when() and thenReturn() or doReturn(). This is useful for isolating
tests from static dependencies that are otherwise hard to replace or configure.

12) Tricky: What is the difference between verify() and verifyNoMoreInteractions() in Mockito?

In Mockito, verify() is used to check that specific interactions with a mock object have occurred, such
as a method being called a certain number of times with specific arguments. On the other hand,
verifyNoMoreInteractions() is used after you've made your verifications to ensure that no additional
interactions took place with the mock beyond what was expected. This helps in ensuring that your
test covers all expected behaviors and that the mocks are not used unexpectedly elsewhere in the
test code.

13) Tricky: How do you mock final classes and methods in Mockito? Is it possible in earlier versions
of Mockito?

Mocking final classes and methods in Mockito is possible using the Mockito-inline extension,
available from Mockito 2.1.0 and onwards. Earlier versions of Mockito did not support mocking of
final classes and methods due to limitations in the Java language and the Mockito framework itself.
By enabling the inline mock maker in your Mockito configuration, you can mock final classes and
methods, allowing for more flexible testing of these types of components.

14) Tricky: How would you mock dependencies that are passed to a method as parameters?

To mock dependencies that are passed to a method as parameters in Mockito, you first create mock
instances of these dependencies using the mock() method. Then, when calling the method under
test, you pass these mock instances as arguments. This allows you to control the behavior of these
dependencies within your tests, using when() and thenReturn() to specify how these mocks should
behave when methods are called on them. This approach is useful for testing interactions and
integrations without relying on real implementations.

15) Tricky: How do you handle method chaining (e.g., foo.bar().baz()) in Mockito?

To handle method chaining in Mockito, such as foo.bar().baz(), you need to mock each part of the
chain. First, create a mock of foo, then stub bar() to return another mock object, which represents
the return of bar(). Finally, specify the behavior of baz() on the second mock. This setup allows you to
control and test each part of the method chain, ensuring that the entire sequence of calls behaves as
expected during tests.

16) What is the difference between a stub and a mock?

The difference between a stub and a mock lies in their intended use and functionality in testing. A
stub is a simplistic implementation that returns hard-coded values, used mainly to fill parameter lists
or set up a test environment. Its purpose is to replace complex real objects and provide predictable
outputs. A mock, on the other hand, is more sophisticated; it not only returns predefined outputs

GenZ Career on YouTube

Subscribe for Interview Preparation
but also verifies how it is interacted with, such as checking the number of method calls or the order
of operations, which is crucial for verifying interactions between components.

17) How do you mock objects in Mockito when using constructor injection?

To mock objects in Mockito when using constructor injection, create mocks for the dependencies
first using the mock() method. Then, pass these mocks as parameters to the constructor of the class
you are testing. This approach allows the class under test to use the mocked dependencies as if they
were real objects, enabling you to control their behavior and verify interactions in your unit tests.
This method effectively isolates the class from its external dependencies, focusing tests on the class's
functionality.

18) Tricky: Can you explain Mockito's RETURNS_DEEP_STUBS and its use case?

RETURNS_DEEP_STUBS in Mockito allows you to mock complex, deeply nested method chains easily.
Instead of manually mocking each level in a method chain, RETURNS_DEEP_STUBS automatically
returns mock objects for each method call in the chain. This is useful when you're dealing with
objects that return other objects, especially in large or deeply nested classes, as it simplifies the
setup and reduces the need for multiple mocks. For example, you can mock a.b().c().d() without
manually mocking each method call.

19) Tricky: How do you mock behavior for methods that depend on randomness (like
Math.random())?

To mock behavior for methods that depend on randomness, like Math.random(), you should abstract
the randomness into a separate class or method that can be mocked. For example, create a
RandomGenerator class with a method that calls Math.random(). Then, in your tests, mock this
RandomGenerator class and control its output using when() and thenReturn(). This allows you to
produce predictable, controlled results for your tests, eliminating randomness and ensuring
consistent test outcomes.

20) How do you combine JUnit and Mockito to write comprehensive unit tests?

To combine JUnit and Mockito for comprehensive unit tests, use JUnit for structuring and running
tests, and Mockito to mock dependencies. Start by setting up test methods in JUnit, then use
Mockito’s mock() to create mock objects for dependencies. Use when() and thenReturn() to define
their behavior. Verify results with JUnit’s assert methods, and use Mockito's verify() to ensure
interactions occurred as expected. This combination ensures isolated and reliable unit testing for
complex code with dependencies.

GenZ Career on YouTube

Subscribe for Interview Preparation