Verification times (times, never, atLeast) in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit verification?

Given the following Mockito verification code, what will be the test result?

JUnit

mockList.add("test");
mockList.add("test");
verify(mockList, times(2)).add("test");

A Test fails because add("test") was called only once.

B Test passes because add("test") was called exactly twice.

C Test fails because times(2) is not a valid verification mode.

D Test passes because add("test") was called at least twice.

💡 Hint

Remember that times(2) means exactly two calls.

The verify statement expects exactly two calls to add("test"). Since the method is called twice, the verification passes.

❓ Predict Output

intermediate

What happens if a method is never called but verified with never()?

Consider this code snippet: mockList.add("hello"); verify(mockList, never()).clear();

JUnit

mockList.add("hello");
verify(mockList, never()).clear();

A Test passes because clear() was never called.

B Test fails because add("hello") was called.

C Test fails because never() requires at least one call.

D Test passes because add("hello") counts as clear() call.

💡 Hint

never() means the method should not be called at all.

The verify statement checks that clear() was never called. Since clear() was not called, the verification passes.

❓ assertion

advanced

Which verification will fail if the method is called once?

Assume the method mockService.process() is called exactly once. Which verify statement will fail?

JUnit

mockService.process();

A verify(mockService, times(1)).process();

B verify(mockService).process();

C verify(mockService, never()).process();

D verify(mockService, atLeast(2)).process();

💡 Hint

atLeast(2) means two or more calls are expected.

Since process() is called only once, atLeast(2) verification fails because it expects two or more calls.

🔧 Debug

advanced

Identify the error in this verification code

What is wrong with this verification code snippet? verify(mockObj, times(0)).execute();

JUnit

verify(mockObj, times(0)).execute();

A times(0) is valid and means the method was never called.

B times(0) means the method was called once.

C times(0) causes a runtime exception.

D times(0) is invalid; use never() instead.

💡 Hint

times(0) and never() are equivalent in Mockito.

times(0) is a valid verification mode meaning the method was not called. It is equivalent to never().

❓ framework

expert

Which verification mode best fits this scenario?

You want to verify that a method was called at least once but you don't care how many times exactly. Which verification mode should you use?

A never()

B times(1)

C atLeastOnce()

D times(0)

💡 Hint

Think about a verification mode that allows one or more calls.

atLeastOnce() verifies the method was called one or more times, matching the scenario.